Commit 2857ca1edc1c3fa83298d2e8f6d505a3776f1ae3 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-09-28 12:16:41-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2024-09-28 12:16:41-07:00
log	2857ca1edc1c3fa83298d2e8f6d505a3776f1ae3
tree	1b47bb75eb6f29f9da11c93ac7ea924a8bfb326a
parent	777e722b0618afc524aa83cea89526b18413c7a6

revert safety test cases to rely on deprecated old API

in case someone wants to pursue the idea of making the panic interface a
struct, this will reduce churn.

92 files changed, 92 insertions(+), 1012 deletions(-)

test
- cases
  - 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

test/cases/safety/@alignCast misaligned.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "incorrect alignment")) {	5	if (std.mem.eql(u8, message, "incorrect alignment")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,17 +1,7 @@	...	@@ -1,17 +1,7 @@
1	const std = @import("std");	1	const std = @import("std");
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
3		3
4	pub const Panic = struct {	4	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
15	_ = message;	5	_ = message;
16	_ = stack_trace;	6	_ = stack_trace;
17	std.process.exit(0);	7	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "invalid enum value")) {	5	if (std.mem.eql(u8, message, "invalid enum value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "invalid error code")) {	5	if (std.mem.eql(u8, message, "invalid error code")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "invalid error code")) {	5	if (std.mem.eql(u8, message, "invalid error code")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {	5	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {	5	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {	5	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {	5	if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {	5	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {	5	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "incorrect alignment")) {	5	if (std.mem.eql(u8, message, "incorrect alignment")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "invalid enum value")) {	5	if (std.mem.eql(u8, message, "invalid enum value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "invalid enum value")) {	5	if (std.mem.eql(u8, message, "invalid enum value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {	5	if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/array slice sentinel mismatch.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {	5	if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/bad union field access.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) {	5	if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/calling panic.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "oh no")) {	5	if (std.mem.eql(u8, message, "oh no")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "exact division produced remainder")) {	5	if (std.mem.eql(u8, message, "exact division produced remainder")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "invalid error code")) {	5	if (std.mem.eql(u8, message, "invalid error code")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/empty slice with sentinel out of bounds.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {	5	if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "exact division produced remainder")) {	5	if (std.mem.eql(u8, message, "exact division produced remainder")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/exact division failure.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "exact division produced remainder")) {	5	if (std.mem.eql(u8, message, "exact division produced remainder")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/for_len_mismatch.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {	5	if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/for_len_mismatch_three.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {	5	if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/integer addition overflow.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "division by zero")) {	5	if (std.mem.eql(u8, message, "division by zero")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "division by zero")) {	5	if (std.mem.eql(u8, message, "division by zero")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/integer multiplication overflow.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/integer negation overflow.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/integer subtraction overflow.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = message;	4	_ = message;
15	_ = stack_trace;	5	_ = stack_trace;
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/memcpy_alias.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "@memcpy arguments alias")) {	5	if (std.mem.eql(u8, message, "@memcpy arguments alias")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/memcpy_len_mismatch.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) {	5	if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/memset_array_undefined_bytes.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/memset_array_undefined_large.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/memset_slice_undefined_bytes.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/memset_slice_undefined_large.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/modrem by zero.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "division by zero")) {	5	if (std.mem.eql(u8, message, "division by zero")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/modulus by zero.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "division by zero")) {	5	if (std.mem.eql(u8, message, "division by zero")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/noreturn returned.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "'noreturn' function returned")) {	5	if (std.mem.eql(u8, message, "'noreturn' function returned")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = message;	4	_ = message;
15	_ = stack_trace;	5	_ = stack_trace;
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to use null value")) {	5	if (std.mem.eql(u8, message, "attempt to use null value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to use null value")) {	5	if (std.mem.eql(u8, message, "attempt to use null value")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/out of bounds array slice by length.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) {	5	if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/out of bounds slice access.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {	5	if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {	5	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {	5	if (std.mem.eql(u8, message, "cast causes pointer to be null")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/pointer slice sentinel mismatch.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {	5	if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "division by zero")) {	5	if (std.mem.eql(u8, message, "division by zero")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = message;	4	_ = message;
15	_ = stack_trace;	5	_ = stack_trace;
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = message;	4	_ = message;
15	_ = stack_trace;	5	_ = stack_trace;
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = message;	4	_ = message;
15	_ = stack_trace;	5	_ = stack_trace;
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = message;	4	_ = message;
15	_ = stack_trace;	5	_ = stack_trace;
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {	5	if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {	5	if (std.mem.eql(u8, message, "shift amount is greater than the type size")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {	5	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {	5	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "left shift overflowed bits")) {	5	if (std.mem.eql(u8, message, "left shift overflowed bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "right shift overflowed bits")) {	5	if (std.mem.eql(u8, message, "right shift overflowed bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {	5	if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) {	5	if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {	5	if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/slice slice sentinel mismatch.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {	5	if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/slice start index greater than end index.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) {	5	if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {	5	if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/slice with sentinel out of bounds.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {	5	if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to use null value")) {	5	if (std.mem.eql(u8, message, "attempt to use null value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to use null value")) {	5	if (std.mem.eql(u8, message, "attempt to use null value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "switch on corrupt value")) {	5	if (std.mem.eql(u8, message, "switch on corrupt value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "switch on corrupt value")) {	5	if (std.mem.eql(u8, message, "switch on corrupt value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "switch on corrupt value")) {	5	if (std.mem.eql(u8, message, "switch on corrupt value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "switch on corrupt value")) {	5	if (std.mem.eql(u8, message, "switch on corrupt value")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "switch on corrupt value")) {	5	if (std.mem.eql(u8, message, "switch on corrupt value")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/truncating vector cast.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {	5	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/unreachable.zig+1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "reached unreachable code")) {	5	if (std.mem.eql(u8, message, "reached unreachable code")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {	5	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "left shift overflowed bits")) {	5	if (std.mem.eql(u8, message, "left shift overflowed bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "right shift overflowed bits")) {	5	if (std.mem.eql(u8, message, "right shift overflowed bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {	5	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/unwrap error switch.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {	5	if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
16	std.process.exit(0);	6	std.process.exit(0);

test/cases/safety/unwrap error.zig +1-11

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {	5	if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {	5	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer cast truncated bits")) {	5	if (std.mem.eql(u8, message, "integer cast truncated bits")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "integer overflow")) {	5	if (std.mem.eql(u8, message, "integer overflow")) {
16	std.process.exit(0);	6	std.process.exit(0);

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

...	@@ -1,16 +1,6 @@	...	@@ -1,16 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub const Panic = struct {	3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
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 {
14	_ = stack_trace;	4	_ = stack_trace;
15	if (std.mem.eql(u8, message, "invalid error code")) {	5	if (std.mem.eql(u8, message, "invalid error code")) {
16	std.process.exit(0);	6	std.process.exit(0);