diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig
index 6e9d16d76d2467302091a84a54d924d80ac9cde0..c29f126c9f764dcc6738fca24b9096cc4e2083fc 100644
--- a/test/cases/compile_errors/panic_has_source_location.zig
+++ b/test/cases/compile_errors/panic_has_source_location.zig
@@ -6,7 +6,10 @@ export fn foo() void {
     @panic("oh no");
 }
 
-pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn {
+    _ = cause;
+    _ = ert;
+    _ = ra;
     @compileError("panic");
 }
 
@@ -14,4 +17,4 @@ pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
 // backend=stage2
 // target=native
 //
-// :10:5: error: panic
+// :13:5: error: panic
diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig
index ade27c2747a8f8c0caadcb83d3832709b019062e..b514810730caef6666543804e7bf7d0837b620b3 100644
--- a/test/cases/safety/@alignCast misaligned.zig	
+++ b/test/cases/safety/@alignCast misaligned.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "incorrect alignment")) {
+    if (cause == .incorrect_alignment) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@enumFromInt - no matching tag value.zig b/test/cases/safety/@enumFromInt - no matching tag value.zig
index 5051869cc0cbdbc6ac8f7760445def783a94dcf7..10f526770294624158bf2aecf078b3e2d6f03318 100644
--- a/test/cases/safety/@enumFromInt - no matching tag value.zig	
+++ b/test/cases/safety/@enumFromInt - no matching tag value.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "invalid enum value")) {
+    if (cause == .invalid_enum_value) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@errorCast error not present in destination.zig b/test/cases/safety/@errorCast error not present in destination.zig
index ff86e1f783828cd38a63d359290f6f6250a000e6..73b87ad20e6582447950a26a687b66471fc50dca 100644
--- a/test/cases/safety/@errorCast error not present in destination.zig	
+++ b/test/cases/safety/@errorCast error not present in destination.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "invalid error code")) {
+    if (cause == .invalid_error_code) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@errorCast error union casted to disjoint set.zig b/test/cases/safety/@errorCast error union casted to disjoint set.zig
index c9da2fc636aec47a6493d3580f3f6328c16bcff7..bdb2d80760cd77a5ee6f640e59189dc8f186356b 100644
--- a/test/cases/safety/@errorCast error union casted to disjoint set.zig	
+++ b/test/cases/safety/@errorCast error union casted to disjoint set.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "invalid error code")) {
+    if (cause == .invalid_error_code) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig
index a33da87f0fa8a0891b395be27ee7ac3c12fcec70..daf5069e61a83c81c3d38442b0001b6a9d7f91da 100644
--- a/test/cases/safety/@intCast to u0.zig	
+++ b/test/cases/safety/@intCast to u0.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
+    if (cause == .cast_truncated_data) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig
index a5a8d831b337096d75ea57996412eee383d19a35..d029f9034302268dff077a1d79a3a8b6fedb912f 100644
--- a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
+    if (cause == .integer_part_out_of_bounds) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig
index 1bf1a667659f22677f73779f4a74d2c21f258f5a..ea2365ea6dd11adbf4552bd2e100b3b9c560d5d8 100644
--- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
+    if (cause == .integer_part_out_of_bounds) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig
index 15a9fa7ad188181a19477f31f0a8de33417cc6f5..1bdc23982a17df75a74a6661ff89767a5e7da2fe 100644
--- a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig	
+++ b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
+    if (cause == .integer_part_out_of_bounds) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig
index f8c448855e3422d93fd5686c414ee928231896fa..2788a31fd915162e165c94c72a62e358c54817f5 100644
--- a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig	
+++ b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
+    if (cause == .cast_to_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig
index c9ae253df7bafa45aea06a4f4985245d6ab5dc27..81e4500115731b3ed002c0ee231162ec1dc235f4 100644
--- a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig	
+++ b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
+    if (cause == .cast_to_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig
index 3952ab9baa2f8efbdebb037abcea2ff58c440968..2c291f9ad3552f174da1fa97b4ba52591699ec33 100644
--- a/test/cases/safety/@ptrFromInt with misaligned address.zig	
+++ b/test/cases/safety/@ptrFromInt with misaligned address.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "incorrect alignment")) {
+    if (cause == .incorrect_alignment) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig
index e23cd1fcf6929a4b771c1cd271f3901ca31740b6..a89dc72a9768e0c450c46f5d44800ab0baee590b 100644
--- a/test/cases/safety/@tagName on corrupted enum value.zig	
+++ b/test/cases/safety/@tagName on corrupted enum value.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "invalid enum value")) {
+    if (cause == .invalid_enum_value) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig
index 09d8276d23393684a4fba7ce0650e6c26b38a091..799a9c6a177f915ffb82e34ddc0d9efa72c9eb9b 100644
--- a/test/cases/safety/@tagName on corrupted union value.zig	
+++ b/test/cases/safety/@tagName on corrupted union value.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "invalid enum value")) {
+    if (cause == .invalid_enum_value) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig
index da20d988691f23dce04855201d41f734dce2e243..aea05a6b4144d545194a745325387b7426a70acd 100644
--- a/test/cases/safety/array slice sentinel mismatch vector.zig	
+++ b/test/cases/safety/array slice sentinel mismatch vector.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {
+    if (cause == .sentinel_mismatch_other) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig
index fc196186732d58c82f6056c356fb81c5205df768..2e9bcf93661440ad39211fc8022b5b5e4ec372ea 100644
--- a/test/cases/safety/array slice sentinel mismatch.zig	
+++ b/test/cases/safety/array slice sentinel mismatch.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
-        std.process.exit(0);
+    switch (cause) {
+        .sentinel_mismatch_usize => |info| {
+            if (info.expected == 0 and info.found == 4) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig
index c6706d41764d96258fc533c5841b780867042b75..d73897f0f37590a30fd4bfb331e498034883e1e8 100644
--- a/test/cases/safety/bad union field access.zig	
+++ b/test/cases/safety/bad union field access.zig	
@@ -1,9 +1,16 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) {
-        std.process.exit(0);
+    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 => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig
index 832bc5f19ad2bde55213cd871b200d3a92b53619..d77f0dd91161d038fd4c65347c5a5b516ef439e4 100644
--- a/test/cases/safety/calling panic.zig	
+++ b/test/cases/safety/calling panic.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "oh no")) {
-        std.process.exit(0);
+    switch (cause) {
+        .explicit_call => |message| {
+            if (std.mem.eql(u8, message, "oh no")) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig
index a72b2fcca2ca52a5a704735d93b97aad553024be..50dac0411c5a7908cf64a4b7b1440e5288e212ea 100644
--- a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
+++ b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "exact division produced remainder")) {
+    if (cause == .exact_division_remainder) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/cast integer to global error and no code matches.zig b/test/cases/safety/cast integer to global error and no code matches.zig
index 61daf07a2ba2315d0a4b21f9f9269f3d5589a91a..f6c5410a7b2a53b361c2842ab09bcd9778256b1d 100644
--- a/test/cases/safety/cast integer to global error and no code matches.zig	
+++ b/test/cases/safety/cast integer to global error and no code matches.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "invalid error code")) {
+    if (cause == .invalid_error_code) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty slice with sentinel out of bounds.zig
index 69201fde307c7e5c2c13f34780a171dda1b34990..2c0a4ebb403a85edf3085535b79d1cb6ed0c55fe 100644
--- a/test/cases/safety/empty slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/empty slice with sentinel out of bounds.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
-        std.process.exit(0);
+    switch (cause) {
+        .index_out_of_bounds => |info| {
+            if (info.index == 1 and info.len == 0) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig
index c5df2b276f175ddc9f8bfa9875eb4425263d7821..8d65d833e1349ab453a4bb61a74fb0757f9645b3 100644
--- a/test/cases/safety/exact division failure - vectors.zig	
+++ b/test/cases/safety/exact division failure - vectors.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "exact division produced remainder")) {
+    if (cause == .exact_division_remainder) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig
index cdf1b1fb8d31809e308b1235572e473be5cb4c1f..8fa31d6ee050a7265433f276b477bdcadf8669be 100644
--- a/test/cases/safety/exact division failure.zig	
+++ b/test/cases/safety/exact division failure.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "exact division produced remainder")) {
+    if (cause == .exact_division_remainder) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig
index ee21b947d7eeb22a8072ca1360e5a9b5659a3a3e..37a0761ee92e849ebff619a9642f97798d958b7c 100644
--- a/test/cases/safety/for_len_mismatch.zig
+++ b/test/cases/safety/for_len_mismatch.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
+    if (cause == .for_len_mismatch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig
index 70f854def51f8152e7255dcb034b1a8a322c5e50..3f1f1ac23006a605c737f07151700597ae106135 100644
--- a/test/cases/safety/for_len_mismatch_three.zig
+++ b/test/cases/safety/for_len_mismatch_three.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
+    if (cause == .for_len_mismatch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig
index f8e3f0bf0aa6e4f032cf376f78d411c7a30f6f1a..1ddb3588bccf6167dd7b3393fdd62846ead99afa 100644
--- a/test/cases/safety/ignored expression integer overflow.zig	
+++ b/test/cases/safety/ignored expression integer overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig
index 4f7c5b2cb3f5570a621497b822b4b683ed8dd358..8aea6c7616243e7687c3d81c91b4633c10f7bfa8 100644
--- a/test/cases/safety/integer addition overflow.zig	
+++ b/test/cases/safety/integer addition overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig
index 6e2af616b9090d73ecd6b12885ad73d48017ac80..3ac58efd313dda36ac5a890fbfa7808130d5396b 100644
--- a/test/cases/safety/integer division by zero - vectors.zig	
+++ b/test/cases/safety/integer division by zero - vectors.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "division by zero")) {
+    if (cause == .divide_by_zero) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig
index 0d1b79d26d8f2fa8d8f8553b8d2e1319f16df9df..7f14acc9a4b80a6119a3ed2d87839aac3f64041b 100644
--- a/test/cases/safety/integer division by zero.zig	
+++ b/test/cases/safety/integer division by zero.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "division by zero")) {
+    if (cause == .divide_by_zero) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig
index 641801277dbd38eef497144adb4398f94bdae539..d90d65ed86d6eb7e263d71e4ddc5e6384f212acf 100644
--- a/test/cases/safety/integer multiplication overflow.zig	
+++ b/test/cases/safety/integer multiplication overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig
index 3d4c134c4a6822bc50966d7d85e4242a18c359cf..9a569b5338c8bbc0ee14aac40485fa2efa13dd7b 100644
--- a/test/cases/safety/integer negation overflow.zig	
+++ b/test/cases/safety/integer negation overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig
index 84a16f55b870cac727651d6d68edfa3b18922ac0..a6591dd9ec42d6b8007fd560d96d5f12002242c8 100644
--- a/test/cases/safety/integer subtraction overflow.zig	
+++ b/test/cases/safety/integer subtraction overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig
index d87a7bf6aa4df1a6f7cb622e953d8bcf1a693c93..191a37f8eb77422e865734277581c6d168fe4684 100644
--- a/test/cases/safety/memcpy_alias.zig
+++ b/test/cases/safety/memcpy_alias.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "@memcpy arguments alias")) {
+    if (cause == .memcpy_alias) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig
index 6ca36abccbbf5a3f7818b3483a4e156cf6a9c8ac..aa5bb92732e817d8ed028c336f95c27c6d755c5f 100644
--- a/test/cases/safety/memcpy_len_mismatch.zig
+++ b/test/cases/safety/memcpy_len_mismatch.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) {
+    if (cause == .memcpy_len_mismatch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig
index e0ce2dac0443a75062abba0f053a3aa5cd5344ed..c1c86df1aa54b4b7d82441b17e38ed7356036547 100644
--- a/test/cases/safety/memset_array_undefined_bytes.zig
+++ b/test/cases/safety/memset_array_undefined_bytes.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig
index dbc1cf4420243a89e8253079a5939b5aa355dfda..3cab2f4c5fcefdfe4cc8b24350007761ca1a1ef6 100644
--- a/test/cases/safety/memset_array_undefined_large.zig
+++ b/test/cases/safety/memset_array_undefined_large.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig
index 4214b5db4b761a629a34bbddbee79957123d8a9c..d6a7e3e5cd95f600f3f0b3286d118b9b0fab8c4c 100644
--- a/test/cases/safety/memset_slice_undefined_bytes.zig
+++ b/test/cases/safety/memset_slice_undefined_bytes.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig
index d1f4f651d33b7deec8fed32b8816d376ff723aaa..a5e572eefdbe77c40cccc75535c62634d4400597 100644
--- a/test/cases/safety/memset_slice_undefined_large.zig
+++ b/test/cases/safety/memset_slice_undefined_large.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig
index f201062c0e8fbf988f0814026a66bf71c5d9cc6d..16616f4801f9fe990cd3cba9923b4ad5d83b1b47 100644
--- a/test/cases/safety/modrem by zero.zig	
+++ b/test/cases/safety/modrem by zero.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "division by zero")) {
+    if (cause == .divide_by_zero) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig
index 6714458979d01bf8105382ac9903be4ecc11c308..454b1cd432180cd0a1bc0aecbafa529b2cc898c0 100644
--- a/test/cases/safety/modulus by zero.zig	
+++ b/test/cases/safety/modulus by zero.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "division by zero")) {
+    if (cause == .divide_by_zero) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn returned.zig
index c3c30af37ee46247b3b032ac5acfcd35067832de..ac413089e77e3239f1bad1c38059908f8e1b704f 100644
--- a/test/cases/safety/noreturn returned.zig	
+++ b/test/cases/safety/noreturn returned.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "'noreturn' function returned")) {
+    if (cause == .noreturn_returned) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/optional unwrap operator on C pointer.zig b/test/cases/safety/optional unwrap operator on C pointer.zig
index bd3313265a5012a5d37b6e7da55bbbfa9cdaccc9..59ffe381a483bffc5f8e0573eb05bba726bf48bc 100644
--- a/test/cases/safety/optional unwrap operator on C pointer.zig	
+++ b/test/cases/safety/optional unwrap operator on C pointer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to use null value")) {
+    if (cause == .unwrap_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/optional unwrap operator on null pointer.zig b/test/cases/safety/optional unwrap operator on null pointer.zig
index 9dda4d0a9e07f7e717e0e954f7227f4c17a67675..9b09d63f7bbb59169199c7ecd6ab378eb528763d 100644
--- a/test/cases/safety/optional unwrap operator on null pointer.zig	
+++ b/test/cases/safety/optional unwrap operator on null pointer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to use null value")) {
+    if (cause == .unwrap_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/out of bounds array slice by length.zig b/test/cases/safety/out of bounds array slice by length.zig
index 62768abebf60b7b2243edaf099a5531084c7a492..9ad18972f84940a19d33bf3a7b43e8581c36abfe 100644
--- a/test/cases/safety/out of bounds array slice by length.zig	
+++ b/test/cases/safety/out of bounds array slice by length.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) {
-        std.process.exit(0);
+    switch (cause) {
+        .index_out_of_bounds => |info| {
+            if (info.index == 16 and info.len == 5) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig
index b4c87948a5ce44be34576b64fc0156ac1b3012b5..7b7ac0f8fa26a1afeaa70a868719e9d247092d58 100644
--- a/test/cases/safety/out of bounds slice access.zig	
+++ b/test/cases/safety/out of bounds slice access.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
-        std.process.exit(0);
+    switch (cause) {
+        .index_out_of_bounds => |info| {
+            if (info.index == 4 and info.len == 4) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/pointer casting null to non-optional pointer.zig b/test/cases/safety/pointer casting null to non-optional pointer.zig
index fdf8dc17ce27db05de31bc32e1984ffeee8e41de..ad8921ae92df79b2f438e197bd602627c0a42ab1 100644
--- a/test/cases/safety/pointer casting null to non-optional pointer.zig	
+++ b/test/cases/safety/pointer casting null to non-optional pointer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
+    if (cause == .cast_to_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/pointer casting to null function pointer.zig b/test/cases/safety/pointer casting to null function pointer.zig
index 8f399b66dc279363fd99f44e6b512878b9472b3e..364f66ab1924cc7ba6888b7d594ec73d5ec545ee 100644
--- a/test/cases/safety/pointer casting to null function pointer.zig	
+++ b/test/cases/safety/pointer casting to null function pointer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
+    if (cause == .cast_to_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig
index 3972528edf4251930d01d767a2fb3a85feb9f898..7d79144fcf8ab0674622e302b4273d4d113a601a 100644
--- a/test/cases/safety/pointer slice sentinel mismatch.zig	
+++ b/test/cases/safety/pointer slice sentinel mismatch.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
-        std.process.exit(0);
+    switch (cause) {
+        .sentinel_mismatch_usize => |info| {
+            if (info.expected == 0 and info.found == 4) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig
index 3dc97f6e16fd4ef0d65cabaab77b16c9063dde0e..9fee0aa13ac5231d92fb46dd40b110772456ca5a 100644
--- a/test/cases/safety/remainder division by zero.zig	
+++ b/test/cases/safety/remainder division by zero.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "division by zero")) {
+    if (cause == .divide_by_zero) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/shift left by huge amount.zig b/test/cases/safety/shift left by huge amount.zig
index a038c0ee4442be2c969108f46c3030c0b48fe262..09425b2cc1d2ac87ba699e477788febd3c85fd64 100644
--- a/test/cases/safety/shift left by huge amount.zig	
+++ b/test/cases/safety/shift left by huge amount.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
+    if (cause == .shift_rhs_too_big) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig
index ced81d948d48d2b801a4306a61f83efdb579f3b8..b02e2a01af27d2c1fba55aa8536ffd273ce51c23 100644
--- a/test/cases/safety/shift right by huge amount.zig	
+++ b/test/cases/safety/shift right by huge amount.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
+    if (cause == .shift_rhs_too_big) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig
index 6346d9f1a1dd363e755d1efe50fd1d80fa507eeb..0da140b8f2debddd2a4400016b1defe8baab3532 100644
--- a/test/cases/safety/signed integer division overflow - vectors.zig	
+++ b/test/cases/safety/signed integer division overflow - vectors.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig
index 9d1014ceec08a9fc6db54f4cd42cb9a9ea6359bd..576e3ef7aa50e32547e1762e1cfe0bcb12c4957c 100644
--- a/test/cases/safety/signed integer division overflow.zig	
+++ b/test/cases/safety/signed integer division overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig
index 87c812eddc20f28d255dd99eeeb7de2a032c5072..762719df81656eda302048ab30552bdd8758b182 100644
--- a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig	
+++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
+    if (cause == .negative_to_unsigned) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig
index 5d8c3f88c8a3f7e59008299d726fb378e41ccdb5..765a50d5a562dcee013f0f9b5f15efb70fbd89a4 100644
--- a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig	
+++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
+    if (cause == .negative_to_unsigned) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig
index f9a4db81ce92c36f6e1fd84b204d98c7a8724c27..148d79ca4d61f6f9fa89f71c3723e758c337cb45 100644
--- a/test/cases/safety/signed shift left overflow.zig	
+++ b/test/cases/safety/signed shift left overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "left shift overflowed bits")) {
+    if (cause == .shl_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig
index 7d71b9ffbde3cd9d00ef63cde643c0ad88266142..f89f57a132a6d0010be260a904daf05d77a51c4e 100644
--- a/test/cases/safety/signed shift right overflow.zig	
+++ b/test/cases/safety/signed shift right overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "right shift overflowed bits")) {
+    if (cause == .shr_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig
index 2e3b4d25d52d3023a94093b4b755f3505d24748a..2dee04d1bfa85a495fde9e6d669788a13cf94322 100644
--- a/test/cases/safety/signed-unsigned vector cast.zig	
+++ b/test/cases/safety/signed-unsigned vector cast.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
+    if (cause == .negative_to_unsigned) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig
index 19b9b86c3ba8b6dc4063c3143d1fed7b7b64e2f8..71b32e0c8a50f7b311e6fff0ea4816a040824e57 100644
--- a/test/cases/safety/slice sentinel mismatch - floats.zig	
+++ b/test/cases/safety/slice sentinel mismatch - floats.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) {
+    if (cause == .sentinel_mismatch_other) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig
index a3b4a98575e65b99a5a5403c6b7aebd397d0ca7c..5e69a1d3503260ef377753f07407ac19904f38b1 100644
--- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
+++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
+    if (cause == .sentinel_mismatch_other) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig
index 635706b2c58a42a8f8f1849a06749020f3399200..7f90b9edbfa4a9b4fd69caf8399ccf92545b7404 100644
--- a/test/cases/safety/slice slice sentinel mismatch.zig	
+++ b/test/cases/safety/slice slice sentinel mismatch.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
-        std.process.exit(0);
+    switch (cause) {
+        .sentinel_mismatch_usize => |info| {
+            if (info.expected == 0 and info.found == 4) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/slice start index greater than end index.zig b/test/cases/safety/slice start index greater than end index.zig
index 83d489ab5699f235dce5401e7491e25ae149a14d..5cdf1e46e9471759477a402888ce697ea426b3e1 100644
--- a/test/cases/safety/slice start index greater than end index.zig	
+++ b/test/cases/safety/slice start index greater than end index.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) {
-        std.process.exit(0);
+    switch (cause) {
+        .start_index_greater_than_end => |info| {
+            if (info.start == 10 and info.end == 1) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig
index abb3cc42f092900af57e654016f31918c215407e..09d8fa32a5795aa0acdcee5be6e1c224822248e4 100644
--- a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
-        std.process.exit(0);
+    switch (cause) {
+        .index_out_of_bounds => |info| {
+            if (info.index == 5 and info.len == 4) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig
index 1683dc9d3f329cae0d0ad2e02124f5b05189ff36..1ec06986576715e66fb61c31137a03873a9d01e6 100644
--- a/test/cases/safety/slice with sentinel out of bounds.zig	
+++ b/test/cases/safety/slice with sentinel out of bounds.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
-        std.process.exit(0);
+    switch (cause) {
+        .index_out_of_bounds => |info| {
+            if (info.index == 5 and info.len == 4) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/slicing null C pointer - runtime len.zig b/test/cases/safety/slicing null C pointer - runtime len.zig
index dd73a5011205eb927e6cab8436b503e85714c43c..d4ebbdff18fd35a7ec16d5735e8024d9425b2483 100644
--- a/test/cases/safety/slicing null C pointer - runtime len.zig	
+++ b/test/cases/safety/slicing null C pointer - runtime len.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to use null value")) {
+    if (cause == .unwrap_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig
index 862f2dcfdba6c8a2c0a867c4192d5d5e88974839..b3e50b0ebf1e7d3f203888c0aeada4ac28da1980 100644
--- a/test/cases/safety/slicing null C pointer.zig	
+++ b/test/cases/safety/slicing null C pointer.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to use null value")) {
+    if (cause == .unwrap_null) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/switch else on corrupt enum value - one prong.zig b/test/cases/safety/switch else on corrupt enum value - one prong.zig
index c11227c3bee874dae1a7772f1c1efbd50b7236f8..bc8321a346935693bf5b682b1fa0ffacf8d5a8b2 100644
--- a/test/cases/safety/switch else on corrupt enum value - one prong.zig	
+++ b/test/cases/safety/switch else on corrupt enum value - one prong.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "switch on corrupt value")) {
+    if (cause == .corrupt_switch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/switch else on corrupt enum value - union.zig b/test/cases/safety/switch else on corrupt enum value - union.zig
index a63c78597e66c6960fb752b210394e08025de638..4f6e00c85a0a208936788c8ecb1c5f784848c379 100644
--- a/test/cases/safety/switch else on corrupt enum value - union.zig	
+++ b/test/cases/safety/switch else on corrupt enum value - union.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "switch on corrupt value")) {
+    if (cause == .corrupt_switch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/switch else on corrupt enum value.zig b/test/cases/safety/switch else on corrupt enum value.zig
index 7e050838c086c77808037a71cfc1c912b4d633ed..1d382173992091e80a1c6b632a8abf0a8d051853 100644
--- a/test/cases/safety/switch else on corrupt enum value.zig	
+++ b/test/cases/safety/switch else on corrupt enum value.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "switch on corrupt value")) {
+    if (cause == .corrupt_switch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig
index f89076191172d2d950fc7b9d38dfe7917847b738..159140180881d7f0cee778e4fafba64ae3a21b18 100644
--- a/test/cases/safety/switch on corrupted enum value.zig	
+++ b/test/cases/safety/switch on corrupted enum value.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "switch on corrupt value")) {
+    if (cause == .corrupt_switch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig
index fc93c9d6e7f0a6931921b0b26b65e97436133eb0..1ae72fcbfbf3b66b8d4a7a138dbe7412f4d6fa86 100644
--- a/test/cases/safety/switch on corrupted union value.zig	
+++ b/test/cases/safety/switch on corrupted union value.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "switch on corrupt value")) {
+    if (cause == .corrupt_switch) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig
index ae76d4dec125d709752551a5013f1aaeecefb233..32fb407555974b5236008155c17a6e35e4b89102 100644
--- a/test/cases/safety/truncating vector cast.zig	
+++ b/test/cases/safety/truncating vector cast.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
+    if (cause == .cast_truncated_data) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig
index 818d7e31a5621f5386afd7a7fb06152f9c329c54..b12b1a722f888724992aa1ab76e0a1a0ea6ba308 100644
--- a/test/cases/safety/unreachable.zig
+++ b/test/cases/safety/unreachable.zig
@@ -1,9 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    _ = ret_addr;
-    if (std.mem.eql(u8, message, "reached unreachable code")) {
+    if (cause == .reached_unreachable) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig
index 9bd4c4200702247aaaae4e5998ed6bb5ef626f79..937d5225691536e2522d931b634d27369fac341c 100644
--- a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig	
+++ b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
+    if (cause == .cast_truncated_data) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig
index d38d8f6ecf0640578fcb1062cb0f43c020b59c4d..53fe91c9fb98592b790de9a724df375ee7ea6f0f 100644
--- a/test/cases/safety/unsigned shift left overflow.zig	
+++ b/test/cases/safety/unsigned shift left overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "left shift overflowed bits")) {
+    if (cause == .shl_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig
index 121797a17d4c6809d62e50d716316a972dec67e1..a5389797fc3be05839a6d354665d81157f40fc4a 100644
--- a/test/cases/safety/unsigned shift right overflow.zig	
+++ b/test/cases/safety/unsigned shift right overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "right shift overflowed bits")) {
+    if (cause == .shr_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig
index 32676f7c1cb61f5a1de619e337160ff8f345bcaa..aab2f5ae168a1ea9369a4ae51f8ba79a0b2da2e9 100644
--- a/test/cases/safety/unsigned-signed vector cast.zig	
+++ b/test/cases/safety/unsigned-signed vector cast.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
+    if (cause == .cast_truncated_data) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig
index 0723a9fb246a81f4e9ea60e90f339fb191bebf66..dd587c48653c5a32426bbbedba062e33a9121423 100644
--- a/test/cases/safety/unwrap error switch.zig	
+++ b/test/cases/safety/unwrap error switch.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
-        std.process.exit(0);
+    switch (cause) {
+        .unwrap_error => |err| {
+            if (err == error.Whatever) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig
index e2d7ea725b8b50a0797159dc9cf6b07c47eace57..a2ac8f50461c19d27255cc2d42d455cbdd8a91e8 100644
--- a/test/cases/safety/unwrap error.zig	
+++ b/test/cases/safety/unwrap error.zig	
@@ -1,9 +1,14 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
-        std.process.exit(0);
+    switch (cause) {
+        .unwrap_error => |err| {
+            if (err == error.Whatever) {
+                std.process.exit(0);
+            }
+        },
+        else => {},
     }
     std.process.exit(1);
 }
diff --git a/test/cases/safety/value does not fit in shortening cast - u0.zig b/test/cases/safety/value does not fit in shortening cast - u0.zig
index ec111a2caedd44a8133421de3211dcf56d9e1349..d06d1cf440d4ae4439be05c5a80eff544757611d 100644
--- a/test/cases/safety/value does not fit in shortening cast - u0.zig	
+++ b/test/cases/safety/value does not fit in shortening cast - u0.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
+    if (cause == .cast_truncated_data) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/value does not fit in shortening cast.zig b/test/cases/safety/value does not fit in shortening cast.zig
index a5ea41659e86b0b94e411cfdccc74577a4d820ab..3f55f40f963efab093adc9edd8f4dbd6e7e8953c 100644
--- a/test/cases/safety/value does not fit in shortening cast.zig	
+++ b/test/cases/safety/value does not fit in shortening cast.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer cast truncated bits")) {
+    if (cause == .cast_truncated_data) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig
index 21c26eeb4e477673c751cce3bb477e22ac57ef12..3e3145db862da53af946766bad333afe7e1faa59 100644
--- a/test/cases/safety/vector integer addition overflow.zig	
+++ b/test/cases/safety/vector integer addition overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig
index 8678eccec6fecb65087e062dc04b3d64c997b209..eceb507efa16630efc9875324196468daf06e028 100644
--- a/test/cases/safety/vector integer multiplication overflow.zig	
+++ b/test/cases/safety/vector integer multiplication overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig
index 5f8becad177ce4cb58b0a7ec818f603a0b1c1cfd..5f408dab8b6d73b9f22f280d19a36dc372715c23 100644
--- a/test/cases/safety/vector integer negation overflow.zig	
+++ b/test/cases/safety/vector integer negation overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig
index 82c03421210496a4ef6861f3b73790680419f64a..c858ac5e341fd006d4fc2b69d2a61fe5265cb255 100644
--- a/test/cases/safety/vector integer subtraction overflow.zig	
+++ b/test/cases/safety/vector integer subtraction overflow.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "integer overflow")) {
+    if (cause == .integer_overflow) {
         std.process.exit(0);
     }
     std.process.exit(1);
diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig
index 78340db3163c7d1e3e130e12d740bee32dc04355..591e4b62ef9eae8d9e6fc4f2888dd270f4b0870c 100644
--- a/test/cases/safety/zero casted to error.zig	
+++ b/test/cases/safety/zero casted to error.zig	
@@ -1,8 +1,8 @@
 const std = @import("std");
 
-pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
+pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
     _ = stack_trace;
-    if (std.mem.eql(u8, message, "invalid error code")) {
+    if (cause == .invalid_error_code) {
         std.process.exit(0);
     }
     std.process.exit(1);