Commit 7f4c0e010d1eaa47533a711c781783e808494083 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-09-26 17:14:17-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-09-26 17:14:17-07:00
log	7f4c0e010d1eaa47533a711c781783e808494083
tree	7aef83ef1185994606b4573630e1ed96a5ebee5d
parent	db8c0744767b3d472f9682827a312a8ffed74adf

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)

95 files changed, 1129 insertions(+), 270 deletions(-)

lib
- std
  - builtin.zig
  - debug
    SimplePanic.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/builtin.zig+16-7

 @@ -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"))
+/// To be deleted after 0.14.0 is released.
-    root.panic
+pub const panic: PanicFn = Panic.call;
-else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic"))
-    root.os.panic
-else
-    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.

lib/std/debug/SimplePanic.zig+1-1

...	@@ -28,7 +28,7 @@ pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn {	...	@@ -28,7 +28,7 @@ pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn {
28		28
29	pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn {	29	pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn {
30	_ = ert;	30	_ = ert;
31	_ = err;	31	_ = &err;
32	call("attempt to unwrap error", null, null);	32	call("attempt to unwrap error", null, null);
33	}	33	}
34		34

test/cases/compile_errors/panic_has_source_location.zig+2-5

...	@@ -6,10 +6,7 @@ export fn foo() void {	...	@@ -6,10 +6,7 @@ export fn foo() void {
6	@panic("oh no");	6	@panic("oh no");
7	}	7	}
8		8
9	pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn {	9	pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
10	_ = cause;
11	_ = ert;
12	_ = ra;
13	@compileError("panic");	10	@compileError("panic");
14	}	11	}
15		12
...	@@ -17,4 +14,4 @@ pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?	...	@@ -17,4 +14,4 @@ pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?
17	// backend=stage2	14	// backend=stage2
18	// target=native	15	// target=native
19	//	16	//
20	// :13:5: error: panic	17	// :10:5: error: panic

test/cases/safety/@alignCast misaligned.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .incorrect_alignment) {	15	if (std.mem.eql(u8, message, "incorrect alignment")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@asyncCall with too small a frame.zig +11-1

...	@@ -1,7 +1,17 @@	...	@@ -1,7 +1,17 @@
1	const std = @import("std");	1	const std = @import("std");
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
3		3
4	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	4	pub const Panic = struct {
		5	pub const call = panic;
		6	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		7	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		8	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		9	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		10	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		11	pub const messages = std.debug.FormattedPanic.messages;
		12	};
		13
		14	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
5	_ = message;	15	_ = message;
6	_ = stack_trace;	16	_ = stack_trace;
7	std.process.exit(0);	17	std.process.exit(0);

test/cases/safety/@enumFromInt - no matching tag value.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .invalid_enum_value) {	15	if (std.mem.eql(u8, message, "invalid enum value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@errorCast error not present in destination.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .invalid_error_code) {	15	if (std.mem.eql(u8, message, "invalid error code")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@errorCast error union casted to disjoint set.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .invalid_error_code) {	15	if (std.mem.eql(u8, message, "invalid error code")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@intCast to u0.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_truncated_data) {	15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@intFromFloat cannot fit - negative out of range.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_part_out_of_bounds) {	15	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_part_out_of_bounds) {	15	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@intFromFloat cannot fit - positive out of range.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_part_out_of_bounds) {	15	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_to_null) {	15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_to_null) {	15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@ptrFromInt with misaligned address.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .incorrect_alignment) {	15	if (std.mem.eql(u8, message, "incorrect alignment")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@tagName on corrupted enum value.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .invalid_enum_value) {	15	if (std.mem.eql(u8, message, "invalid enum value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/@tagName on corrupted union value.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .invalid_enum_value) {	15	if (std.mem.eql(u8, message, "invalid enum value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/array slice sentinel mismatch vector.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .sentinel_mismatch_other) {	15	if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/array slice sentinel mismatch.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
-        .sentinel_mismatch_usize => |info| {
+        std.process.exit(0);
-            if (info.expected == 0 and info.found == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/bad union field access.zig +13-10

 @@ -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) {
+    if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) {
-        .inactive_union_field => |info| {
+        std.process.exit(0);
-            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);
 }

test/cases/safety/calling panic.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "oh no")) {
-        .explicit_call => |message| {
+        std.process.exit(0);
-            if (std.mem.eql(u8, message, "oh no")) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/cast []u8 to bigger slice of wrong size.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .exact_division_remainder) {	15	if (std.mem.eql(u8, message, "exact division produced remainder")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/cast integer to global error and no code matches.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .invalid_error_code) {	15	if (std.mem.eql(u8, message, "invalid error code")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/empty slice with sentinel out of bounds.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
-        .index_out_of_bounds => |info| {
+        std.process.exit(0);
-            if (info.index == 1 and info.len == 0) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/exact division failure - vectors.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .exact_division_remainder) {	15	if (std.mem.eql(u8, message, "exact division produced remainder")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/exact division failure.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .exact_division_remainder) {	15	if (std.mem.eql(u8, message, "exact division produced remainder")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/for_len_mismatch.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .for_len_mismatch) {	15	if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/for_len_mismatch_three.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .for_len_mismatch) {	15	if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/ignored expression integer overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/integer addition overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/integer division by zero - vectors.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .divide_by_zero) {	15	if (std.mem.eql(u8, message, "division by zero")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/integer division by zero.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .divide_by_zero) {	15	if (std.mem.eql(u8, message, "division by zero")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/integer multiplication overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/integer negation overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/integer subtraction overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/invalid resume of async function.zig +11-1

...	@@ -1,6 +1,16 @@	...	@@ -1,6 +1,16 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = message;	14	_ = message;
5	_ = stack_trace;	15	_ = stack_trace;
6	std.process.exit(0);	16	std.process.exit(0);

test/cases/safety/memcpy_alias.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .memcpy_alias) {	15	if (std.mem.eql(u8, message, "@memcpy arguments alias")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/memcpy_len_mismatch.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .memcpy_len_mismatch) {	15	if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/memset_array_undefined_bytes.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/memset_array_undefined_large.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/memset_slice_undefined_bytes.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/memset_slice_undefined_large.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/modrem by zero.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .divide_by_zero) {	15	if (std.mem.eql(u8, message, "division by zero")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/modulus by zero.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .divide_by_zero) {	15	if (std.mem.eql(u8, message, "division by zero")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/noreturn returned.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .noreturn_returned) {	15	if (std.mem.eql(u8, message, "'noreturn' function returned")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/nosuspend function call, callee suspends.zig +11-1

...	@@ -1,6 +1,16 @@	...	@@ -1,6 +1,16 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = message;	14	_ = message;
5	_ = stack_trace;	15	_ = stack_trace;
6	std.process.exit(0);	16	std.process.exit(0);

test/cases/safety/optional unwrap operator on C pointer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .unwrap_null) {	15	if (std.mem.eql(u8, message, "attempt to use null value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/optional unwrap operator on null pointer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .unwrap_null) {	15	if (std.mem.eql(u8, message, "attempt to use null value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/out of bounds array slice by length.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) {
-        .index_out_of_bounds => |info| {
+        std.process.exit(0);
-            if (info.index == 16 and info.len == 5) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/out of bounds slice access.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
-        .index_out_of_bounds => |info| {
+        std.process.exit(0);
-            if (info.index == 4 and info.len == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/pointer casting null to non-optional pointer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_to_null) {	15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/pointer casting to null function pointer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_to_null) {	15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/pointer slice sentinel mismatch.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
-        .sentinel_mismatch_usize => |info| {
+        std.process.exit(0);
-            if (info.expected == 0 and info.found == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/remainder division by zero.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .divide_by_zero) {	15	if (std.mem.eql(u8, message, "division by zero")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/resuming a function which is awaiting a call.zig +11-1

...	@@ -1,6 +1,16 @@	...	@@ -1,6 +1,16 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = message;	14	_ = message;
5	_ = stack_trace;	15	_ = stack_trace;
6	std.process.exit(0);	16	std.process.exit(0);

test/cases/safety/resuming a function which is awaiting a frame.zig +11-1

...	@@ -1,6 +1,16 @@	...	@@ -1,6 +1,16 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = message;	14	_ = message;
5	_ = stack_trace;	15	_ = stack_trace;
6	std.process.exit(0);	16	std.process.exit(0);

test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig +11-1

...	@@ -1,6 +1,16 @@	...	@@ -1,6 +1,16 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = message;	14	_ = message;
5	_ = stack_trace;	15	_ = stack_trace;
6	std.process.exit(0);	16	std.process.exit(0);

test/cases/safety/resuming a non-suspended function which never been suspended.zig +11-1

...	@@ -1,6 +1,16 @@	...	@@ -1,6 +1,16 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = message;	14	_ = message;
5	_ = stack_trace;	15	_ = stack_trace;
6	std.process.exit(0);	16	std.process.exit(0);

test/cases/safety/shift left by huge amount.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .shift_rhs_too_big) {	15	if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/shift right by huge amount.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .shift_rhs_too_big) {	15	if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/signed integer division overflow - vectors.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/signed integer division overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .negative_to_unsigned) {	15	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/signed integer not fitting in cast to unsigned integer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .negative_to_unsigned) {	15	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/signed shift left overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .shl_overflow) {	15	if (std.mem.eql(u8, message, "left shift overflowed bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/signed shift right overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .shr_overflow) {	15	if (std.mem.eql(u8, message, "right shift overflowed bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/signed-unsigned vector cast.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .negative_to_unsigned) {	15	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/slice sentinel mismatch - floats.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .sentinel_mismatch_other) {	15	if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/slice sentinel mismatch - optional pointers.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .sentinel_mismatch_other) {	15	if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/slice slice sentinel mismatch.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
-        .sentinel_mismatch_usize => |info| {
+        std.process.exit(0);
-            if (info.expected == 0 and info.found == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/slice start index greater than end index.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) {
-        .start_index_greater_than_end => |info| {
+        std.process.exit(0);
-            if (info.start == 10 and info.end == 1) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/slice with sentinel out of bounds - runtime len.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
-        .index_out_of_bounds => |info| {
+        std.process.exit(0);
-            if (info.index == 5 and info.len == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/slice with sentinel out of bounds.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
-        .index_out_of_bounds => |info| {
+        std.process.exit(0);
-            if (info.index == 5 and info.len == 4) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/slicing null C pointer - runtime len.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .unwrap_null) {	15	if (std.mem.eql(u8, message, "attempt to use null value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/slicing null C pointer.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .unwrap_null) {	15	if (std.mem.eql(u8, message, "attempt to use null value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/switch else on corrupt enum value - one prong.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .corrupt_switch) {	15	if (std.mem.eql(u8, message, "switch on corrupt value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/switch else on corrupt enum value - union.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .corrupt_switch) {	15	if (std.mem.eql(u8, message, "switch on corrupt value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/switch else on corrupt enum value.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .corrupt_switch) {	15	if (std.mem.eql(u8, message, "switch on corrupt value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/switch on corrupted enum value.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .corrupt_switch) {	15	if (std.mem.eql(u8, message, "switch on corrupt value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/switch on corrupted union value.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .corrupt_switch) {	15	if (std.mem.eql(u8, message, "switch on corrupt value")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/truncating vector cast.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_truncated_data) {	15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/unreachable.zig+12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .reached_unreachable) {	15	if (std.mem.eql(u8, message, "reached unreachable code")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_truncated_data) {	15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/unsigned shift left overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .shl_overflow) {	15	if (std.mem.eql(u8, message, "left shift overflowed bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/unsigned shift right overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .shr_overflow) {	15	if (std.mem.eql(u8, message, "right shift overflowed bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/unsigned-signed vector cast.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_truncated_data) {	15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/unwrap error switch.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
-        .unwrap_error => |err| {
+        std.process.exit(0);
-            if (err == error.Whatever) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/unwrap error.zig +13-8

 @@ -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) {
+    if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
-        .unwrap_error => |err| {
+        std.process.exit(0);
-            if (err == error.Whatever) {
-                std.process.exit(0);
-            }
-        },
-        else => {},
     }
     std.process.exit(1);
 }

test/cases/safety/value does not fit in shortening cast - u0.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_truncated_data) {	15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/value does not fit in shortening cast.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .cast_truncated_data) {	15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/vector integer addition overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/vector integer multiplication overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/vector integer negation overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/vector integer subtraction overflow.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .integer_overflow) {	15	if (std.mem.eql(u8, message, "integer overflow")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);

test/cases/safety/zero casted to error.zig +12-2

...	@@ -1,8 +1,18 @@	...	@@ -1,8 +1,18 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {	3	pub const Panic = struct {
		4	pub const call = panic;
		5	pub const unwrapError = std.debug.FormattedPanic.unwrapError;
		6	pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
		7	pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
		8	pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
		9	pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
		10	pub const messages = std.debug.FormattedPanic.messages;
		11	};
		12
		13	fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;	14	_ = stack_trace;
5	if (cause == .invalid_error_code) {	15	if (std.mem.eql(u8, message, "invalid error code")) {
6	std.process.exit(0);	16	std.process.exit(0);
7	}	17	}
8	std.process.exit(1);	18	std.process.exit(1);