Commit 231783f2078bca02a8b861f2d750a61db0c4d581 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-09-25 20:17:21-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-09-26 12:35:14-07:00
log	231783f2078bca02a8b861f2d750a61db0c4d581
tree	65d581f149c30961022cae5c052bbbee640e9da8
parent	e8887829cab0eb1d4a1d578efd1c75a55ab2d060

update test cases to new panic API

86 files changed, 255 insertions(+), 186 deletions(-)

test
- cases
  - compile_errors
    panic_has_source_location.zig
  - safety
    @alignCast misaligned.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
    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
    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
    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

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

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

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "incorrect alignment")) {
	5	if (cause == .incorrect_alignment) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "invalid enum value")) {
	5	if (cause == .invalid_enum_value) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "invalid error code")) {
	5	if (cause == .invalid_error_code) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "invalid error code")) {
	5	if (cause == .invalid_error_code) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer cast truncated bits")) {
	5	if (cause == .cast_truncated_data) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
	5	if (cause == .integer_part_out_of_bounds) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
	5	if (cause == .integer_part_out_of_bounds) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
	5	if (cause == .integer_part_out_of_bounds) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
	5	if (cause == .cast_to_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
	5	if (cause == .cast_to_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "incorrect alignment")) {
	5	if (cause == .incorrect_alignment) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "invalid enum value")) {
	5	if (cause == .invalid_enum_value) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "invalid enum value")) {
	5	if (cause == .invalid_enum_value) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {
	5	if (cause == .sentinel_mismatch_other) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.sentinel_mismatch_usize => \|info\| {
	7	if (info.expected == 0 and info.found == 4) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,9 +1,16 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.inactive_union_field => \|info\| {
	7	if (std.mem.eql(u8, info.active, "int") and
	8	std.mem.eql(u8, info.accessed, "float"))
	9	{
	10	std.process.exit(0);
	11	}
	12	},
	13	else => {},
7	14	}
8	15	std.process.exit(1);
9	16	}

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "oh no")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.explicit_call => \|message\| {
	7	if (std.mem.eql(u8, message, "oh no")) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "exact division produced remainder")) {
	5	if (cause == .exact_division_remainder) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "invalid error code")) {
	5	if (cause == .invalid_error_code) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.index_out_of_bounds => \|info\| {
	7	if (info.index == 1 and info.len == 0) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "exact division produced remainder")) {
	5	if (cause == .exact_division_remainder) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "exact division produced remainder")) {
	5	if (cause == .exact_division_remainder) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
	5	if (cause == .for_len_mismatch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
	5	if (cause == .for_len_mismatch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "division by zero")) {
	5	if (cause == .divide_by_zero) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "division by zero")) {
	5	if (cause == .divide_by_zero) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "@memcpy arguments alias")) {
	5	if (cause == .memcpy_alias) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) {
	5	if (cause == .memcpy_len_mismatch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "division by zero")) {
	5	if (cause == .divide_by_zero) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "division by zero")) {
	5	if (cause == .divide_by_zero) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "'noreturn' function returned")) {
	5	if (cause == .noreturn_returned) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to use null value")) {
	5	if (cause == .unwrap_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to use null value")) {
	5	if (cause == .unwrap_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.index_out_of_bounds => \|info\| {
	7	if (info.index == 16 and info.len == 5) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.index_out_of_bounds => \|info\| {
	7	if (info.index == 4 and info.len == 4) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
	5	if (cause == .cast_to_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
	5	if (cause == .cast_to_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.sentinel_mismatch_usize => \|info\| {
	7	if (info.expected == 0 and info.found == 4) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "division by zero")) {
	5	if (cause == .divide_by_zero) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
	5	if (cause == .shift_rhs_too_big) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
	5	if (cause == .shift_rhs_too_big) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
	5	if (cause == .negative_to_unsigned) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
	5	if (cause == .negative_to_unsigned) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "left shift overflowed bits")) {
	5	if (cause == .shl_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "right shift overflowed bits")) {
	5	if (cause == .shr_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
	5	if (cause == .negative_to_unsigned) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) {
	5	if (cause == .sentinel_mismatch_other) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
	5	if (cause == .sentinel_mismatch_other) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.sentinel_mismatch_usize => \|info\| {
	7	if (info.expected == 0 and info.found == 4) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.start_index_greater_than_end => \|info\| {
	7	if (info.start == 10 and info.end == 1) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.index_out_of_bounds => \|info\| {
	7	if (info.index == 5 and info.len == 4) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.index_out_of_bounds => \|info\| {
	7	if (info.index == 5 and info.len == 4) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to use null value")) {
	5	if (cause == .unwrap_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to use null value")) {
	5	if (cause == .unwrap_null) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "switch on corrupt value")) {
	5	if (cause == .corrupt_switch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "switch on corrupt value")) {
	5	if (cause == .corrupt_switch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "switch on corrupt value")) {
	5	if (cause == .corrupt_switch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "switch on corrupt value")) {
	5	if (cause == .corrupt_switch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "switch on corrupt value")) {
	5	if (cause == .corrupt_switch) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer cast truncated bits")) {
	5	if (cause == .cast_truncated_data) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,9 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, ret_addr: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		_ = ret_addr;
6		if (std.mem.eql(u8, message, "reached unreachable code")) {
	5	if (cause == .reached_unreachable) {
7	6	std.process.exit(0);
8	7	}
9	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer cast truncated bits")) {
	5	if (cause == .cast_truncated_data) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "left shift overflowed bits")) {
	5	if (cause == .shl_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "right shift overflowed bits")) {
	5	if (cause == .shr_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer cast truncated bits")) {
	5	if (cause == .cast_truncated_data) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.unwrap_error => \|err\| {
	7	if (err == error.Whatever) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,9 +1,14 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
6		std.process.exit(0);
	5	switch (cause) {
	6	.unwrap_error => \|err\| {
	7	if (err == error.Whatever) {
	8	std.process.exit(0);
	9	}
	10	},
	11	else => {},
7	12	}
8	13	std.process.exit(1);
9	14	}

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer cast truncated bits")) {
	5	if (cause == .cast_truncated_data) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer cast truncated bits")) {
	5	if (cause == .cast_truncated_data) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "integer overflow")) {
	5	if (cause == .integer_overflow) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);

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

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2	2
3		pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
	3	pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	4	_ = stack_trace;
5		if (std.mem.eql(u8, message, "invalid error code")) {
	5	if (cause == .invalid_error_code) {
6	6	std.process.exit(0);
7	7	}
8	8	std.process.exit(1);