From 7f4c0e010d1eaa47533a711c781783e808494083 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Thu, 26 Sep 2024 17:14:17 -0700 Subject: [PATCH] update safety test cases to new panic API although they would also pass simply reverted to master branch because I made the deprecated API still work for now (to be removed after 0.14.0 is tagged) --- lib/std/builtin.zig | 23 +++++++++++++------ lib/std/debug/SimplePanic.zig | 2 +- .../panic_has_source_location.zig | 7 ++---- test/cases/safety/@alignCast misaligned.zig | 14 +++++++++-- .../@asyncCall with too small a frame.zig | 12 +++++++++- .../@enumFromInt - no matching tag value.zig | 14 +++++++++-- ...rCast error not present in destination.zig | 14 +++++++++-- ...ast error union casted to disjoint set.zig | 14 +++++++++-- test/cases/safety/@intCast to u0.zig | 14 +++++++++-- ...oat cannot fit - negative out of range.zig | 14 +++++++++-- ...loat cannot fit - negative to unsigned.zig | 14 +++++++++-- ...oat cannot fit - positive out of range.zig | 14 +++++++++-- ...o to non-optional byte-aligned pointer.zig | 14 +++++++++-- ...t address zero to non-optional pointer.zig | 14 +++++++++-- .../@ptrFromInt with misaligned address.zig | 14 +++++++++-- .../@tagName on corrupted enum value.zig | 14 +++++++++-- .../@tagName on corrupted union value.zig | 14 +++++++++-- .../array slice sentinel mismatch vector.zig | 14 +++++++++-- .../safety/array slice sentinel mismatch.zig | 21 ++++++++++------- test/cases/safety/bad union field access.zig | 23 +++++++++++-------- test/cases/safety/calling panic.zig | 21 ++++++++++------- ...ast []u8 to bigger slice of wrong size.zig | 14 +++++++++-- ...er to global error and no code matches.zig | 14 +++++++++-- ...mpty slice with sentinel out of bounds.zig | 21 ++++++++++------- .../exact division failure - vectors.zig | 14 +++++++++-- test/cases/safety/exact division failure.zig | 14 +++++++++-- test/cases/safety/for_len_mismatch.zig | 14 +++++++++-- test/cases/safety/for_len_mismatch_three.zig | 14 +++++++++-- .../ignored expression integer overflow.zig | 14 +++++++++-- .../safety/integer addition overflow.zig | 14 +++++++++-- .../integer division by zero - vectors.zig | 14 +++++++++-- .../cases/safety/integer division by zero.zig | 14 +++++++++-- .../integer multiplication overflow.zig | 14 +++++++++-- .../safety/integer negation overflow.zig | 14 +++++++++-- .../safety/integer subtraction overflow.zig | 14 +++++++++-- .../invalid resume of async function.zig | 12 +++++++++- test/cases/safety/memcpy_alias.zig | 14 +++++++++-- test/cases/safety/memcpy_len_mismatch.zig | 14 +++++++++-- .../safety/memset_array_undefined_bytes.zig | 14 +++++++++-- .../safety/memset_array_undefined_large.zig | 14 +++++++++-- .../safety/memset_slice_undefined_bytes.zig | 14 +++++++++-- .../safety/memset_slice_undefined_large.zig | 14 +++++++++-- test/cases/safety/modrem by zero.zig | 14 +++++++++-- test/cases/safety/modulus by zero.zig | 14 +++++++++-- test/cases/safety/noreturn returned.zig | 14 +++++++++-- ...suspend function call, callee suspends.zig | 12 +++++++++- .../optional unwrap operator on C pointer.zig | 14 +++++++++-- ...tional unwrap operator on null pointer.zig | 14 +++++++++-- .../out of bounds array slice by length.zig | 21 ++++++++++------- .../safety/out of bounds slice access.zig | 21 ++++++++++------- ...r casting null to non-optional pointer.zig | 14 +++++++++-- ...inter casting to null function pointer.zig | 14 +++++++++-- .../pointer slice sentinel mismatch.zig | 21 ++++++++++------- .../safety/remainder division by zero.zig | 14 +++++++++-- ...ng a function which is awaiting a call.zig | 12 +++++++++- ...g a function which is awaiting a frame.zig | 12 +++++++++- ...n which has been suspended and resumed.zig | 12 +++++++++- ...ed function which never been suspended.zig | 12 +++++++++- .../safety/shift left by huge amount.zig | 14 +++++++++-- .../safety/shift right by huge amount.zig | 14 +++++++++-- ...ed integer division overflow - vectors.zig | 14 +++++++++-- .../signed integer division overflow.zig | 14 +++++++++-- ...in cast to unsigned integer - widening.zig | 14 +++++++++-- ...ot fitting in cast to unsigned integer.zig | 14 +++++++++-- .../safety/signed shift left overflow.zig | 14 +++++++++-- .../safety/signed shift right overflow.zig | 14 +++++++++-- .../safety/signed-unsigned vector cast.zig | 14 +++++++++-- .../slice sentinel mismatch - floats.zig | 14 +++++++++-- ... sentinel mismatch - optional pointers.zig | 14 +++++++++-- .../safety/slice slice sentinel mismatch.zig | 21 ++++++++++------- ...ice start index greater than end index.zig | 21 ++++++++++------- ...h sentinel out of bounds - runtime len.zig | 21 ++++++++++------- .../slice with sentinel out of bounds.zig | 21 ++++++++++------- .../slicing null C pointer - runtime len.zig | 14 +++++++++-- test/cases/safety/slicing null C pointer.zig | 14 +++++++++-- ...else on corrupt enum value - one prong.zig | 14 +++++++++-- ...tch else on corrupt enum value - union.zig | 14 +++++++++-- .../switch else on corrupt enum value.zig | 14 +++++++++-- .../safety/switch on corrupted enum value.zig | 14 +++++++++-- .../switch on corrupted union value.zig | 14 +++++++++-- test/cases/safety/truncating vector cast.zig | 14 +++++++++-- test/cases/safety/unreachable.zig | 14 +++++++++-- ...ast to signed integer - same bit count.zig | 14 +++++++++-- .../safety/unsigned shift left overflow.zig | 14 +++++++++-- .../safety/unsigned shift right overflow.zig | 14 +++++++++-- .../safety/unsigned-signed vector cast.zig | 14 +++++++++-- test/cases/safety/unwrap error switch.zig | 21 ++++++++++------- test/cases/safety/unwrap error.zig | 21 ++++++++++------- ...e does not fit in shortening cast - u0.zig | 14 +++++++++-- .../value does not fit in shortening cast.zig | 14 +++++++++-- .../vector integer addition overflow.zig | 14 +++++++++-- ...vector integer multiplication overflow.zig | 14 +++++++++-- .../vector integer negation overflow.zig | 14 +++++++++-- .../vector integer subtraction overflow.zig | 14 +++++++++-- test/cases/safety/zero casted to error.zig | 14 +++++++++-- 95 files changed, 1129 insertions(+), 270 deletions(-) diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 664a45f12b86a6dc61426c62bd4644040e6521be..f2cd78160f9d11914b7250f823b24e046104699a 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -762,26 +762,35 @@ pub const TestFn = struct { }; /// Deprecated, use the `Panic` namespace instead. +/// To be deleted after 0.14.0 is released. pub const PanicFn = fn ([]const u8, ?*StackTrace, ?usize) noreturn; - /// Deprecated, use the `Panic` namespace instead. -pub const panic: PanicFn = if (@hasDecl(root, "panic")) - root.panic -else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) - root.os.panic -else - Panic.call; +/// To be deleted after 0.14.0 is released. +pub const panic: PanicFn = Panic.call; /// This namespace is used by the Zig compiler to emit various kinds of safety /// panics. These can be overridden by making a public `Panic` namespace in the /// root source file. pub const Panic: type = if (@hasDecl(root, "Panic")) root.Panic +else if (@hasDecl(root, "panic")) // Deprecated, use `Panic` instead. + DeprecatedPanic else if (builtin.zig_backend == .stage2_riscv64) std.debug.SimplePanic // https://github.com/ziglang/zig/issues/21519 else std.debug.FormattedPanic; +/// To be deleted after 0.14.0 is released. +const DeprecatedPanic = struct { + pub const call = root.panic; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + /// To be deleted after zig1.wasm is updated. pub const panicSentinelMismatch = Panic.sentinelMismatch; /// To be deleted after zig1.wasm is updated. diff --git a/lib/std/debug/SimplePanic.zig b/lib/std/debug/SimplePanic.zig index b8e818c6fc5c66d1008f8068123b5cded51ebdbe..9685642a5c40512eb9c3ecd9c6d7b882c74d2ae1 100644 --- a/lib/std/debug/SimplePanic.zig +++ b/lib/std/debug/SimplePanic.zig @@ -28,7 +28,7 @@ pub fn sentinelMismatch(expected: anytype, found: @TypeOf(expected)) noreturn { pub fn unwrapError(ert: ?*std.builtin.StackTrace, err: anyerror) noreturn { _ = ert; - _ = err; + _ = &err; call("attempt to unwrap error", null, null); } diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig index c29f126c9f764dcc6738fca24b9096cc4e2083fc..6e9d16d76d2467302091a84a54d924d80ac9cde0 100644 --- a/test/cases/compile_errors/panic_has_source_location.zig +++ b/test/cases/compile_errors/panic_has_source_location.zig @@ -6,10 +6,7 @@ export fn foo() void { @panic("oh no"); } -pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ?usize) noreturn { - _ = cause; - _ = ert; - _ = ra; +pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { @compileError("panic"); } @@ -17,4 +14,4 @@ pub fn panic(cause: std.builtin.PanicCause, ert: ?*std.builtin.StackTrace, ra: ? // backend=stage2 // target=native // -// :13:5: error: panic +// :10:5: error: panic diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig index b514810730caef6666543804e7bf7d0837b620b3..393c3ae2f72f7b81a07f2e7b1c16ec8a50085cd0 100644 --- a/test/cases/safety/@alignCast misaligned.zig +++ b/test/cases/safety/@alignCast misaligned.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .incorrect_alignment) { + if (std.mem.eql(u8, message, "incorrect alignment")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@asyncCall with too small a frame.zig b/test/cases/safety/@asyncCall with too small a frame.zig index 3d7cdb3b1d02ff5dc53c829f51acbd2db2b40d41..47d29dc3e06d7e9ad955e6bf150403d363100e57 100644 --- a/test/cases/safety/@asyncCall with too small a frame.zig +++ b/test/cases/safety/@asyncCall with too small a frame.zig @@ -1,7 +1,17 @@ const std = @import("std"); const builtin = @import("builtin"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/cases/safety/@enumFromInt - no matching tag value.zig b/test/cases/safety/@enumFromInt - no matching tag value.zig index 10f526770294624158bf2aecf078b3e2d6f03318..067599c5da7c037958019765baf90c6d050d8df6 100644 --- a/test/cases/safety/@enumFromInt - no matching tag value.zig +++ b/test/cases/safety/@enumFromInt - no matching tag value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_enum_value) { + if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@errorCast error not present in destination.zig b/test/cases/safety/@errorCast error not present in destination.zig index 73b87ad20e6582447950a26a687b66471fc50dca..0d92f9e18cb898cf9c47ebde4240d53d2c47bec0 100644 --- a/test/cases/safety/@errorCast error not present in destination.zig +++ b/test/cases/safety/@errorCast error not present in destination.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@errorCast error union casted to disjoint set.zig b/test/cases/safety/@errorCast error union casted to disjoint set.zig index bdb2d80760cd77a5ee6f640e59189dc8f186356b..6f9de8cf5f1876a46aab97cb0a48b50350d32897 100644 --- a/test/cases/safety/@errorCast error union casted to disjoint set.zig +++ b/test/cases/safety/@errorCast error union casted to disjoint set.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig index daf5069e61a83c81c3d38442b0001b6a9d7f91da..d9bb489c70d88dd2a76760db71663c0d6e22c380 100644 --- a/test/cases/safety/@intCast to u0.zig +++ b/test/cases/safety/@intCast to u0.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig index d029f9034302268dff077a1d79a3a8b6fedb912f..fd7a915366239bb868ee8ec511a448407fa2de31 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_part_out_of_bounds) { + if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig index ea2365ea6dd11adbf4552bd2e100b3b9c560d5d8..0a7195bbc2f3a544332ff79e23830440fbd65a6e 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig +++ b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_part_out_of_bounds) { + if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig index 1bdc23982a17df75a74a6661ff89767a5e7da2fe..395ee133c9226258d37ad852116d3c2a1359674c 100644 --- a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig +++ b/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_part_out_of_bounds) { + if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig index 2788a31fd915162e165c94c72a62e358c54817f5..963fdf70cbb10647f16eefc5edcf47b8a0d14abd 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig index 81e4500115731b3ed002c0ee231162ec1dc235f4..6826343ff752490998fb1578d440f3cd3de52491 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig +++ b/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig index 2c291f9ad3552f174da1fa97b4ba52591699ec33..ebf92b238dc54bcee7b35756f2b08b6b36de665c 100644 --- a/test/cases/safety/@ptrFromInt with misaligned address.zig +++ b/test/cases/safety/@ptrFromInt with misaligned address.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .incorrect_alignment) { + if (std.mem.eql(u8, message, "incorrect alignment")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig index a89dc72a9768e0c450c46f5d44800ab0baee590b..23ababf26470553a2b108b6a24e376ca4f23f847 100644 --- a/test/cases/safety/@tagName on corrupted enum value.zig +++ b/test/cases/safety/@tagName on corrupted enum value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_enum_value) { + if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig index 799a9c6a177f915ffb82e34ddc0d9efa72c9eb9b..38b86ef482913019a8c48db6658154e249190d96 100644 --- a/test/cases/safety/@tagName on corrupted union value.zig +++ b/test/cases/safety/@tagName on corrupted union value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_enum_value) { + if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig index aea05a6b4144d545194a745325387b7426a70acd..0185899c46bb57ff181d4385bf09d73ce37ac679 100644 --- a/test/cases/safety/array slice sentinel mismatch vector.zig +++ b/test/cases/safety/array slice sentinel mismatch vector.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .sentinel_mismatch_other) { + if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig index 2e9bcf93661440ad39211fc8022b5b5e4ec372ea..f645e45f181a35f44015c1ad6d39d2d6c80d020c 100644 --- a/test/cases/safety/array slice sentinel mismatch.zig +++ b/test/cases/safety/array slice sentinel mismatch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .sentinel_mismatch_usize => |info| { - if (info.expected == 0 and info.found == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig index d73897f0f37590a30fd4bfb331e498034883e1e8..7258c37a44af3ab807f343c0f3801255e2e89128 100644 --- a/test/cases/safety/bad union field access.zig +++ b/test/cases/safety/bad union field access.zig @@ -1,16 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .inactive_union_field => |info| { - if (std.mem.eql(u8, info.active, "int") and - std.mem.eql(u8, info.accessed, "float")) - { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig index d77f0dd91161d038fd4c65347c5a5b516ef439e4..7a7c120b6b54433a2244b1ad304532b37581def2 100644 --- a/test/cases/safety/calling panic.zig +++ b/test/cases/safety/calling panic.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .explicit_call => |message| { - if (std.mem.eql(u8, message, "oh no")) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "oh no")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig index 50dac0411c5a7908cf64a4b7b1440e5288e212ea..9590482df1cb4c4cd0173953ece25da7c3cdcabe 100644 --- a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig +++ b/test/cases/safety/cast []u8 to bigger slice of wrong size.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .exact_division_remainder) { + if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/cast integer to global error and no code matches.zig b/test/cases/safety/cast integer to global error and no code matches.zig index f6c5410a7b2a53b361c2842ab09bcd9778256b1d..aec6262275ef0470a3966d2e84af9b6e45722a04 100644 --- a/test/cases/safety/cast integer to global error and no code matches.zig +++ b/test/cases/safety/cast integer to global error and no code matches.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty slice with sentinel out of bounds.zig index 2c0a4ebb403a85edf3085535b79d1cb6ed0c55fe..aa72bb74dd331bce77d623b664994b0c2668c214 100644 --- a/test/cases/safety/empty slice with sentinel out of bounds.zig +++ b/test/cases/safety/empty slice with sentinel out of bounds.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 1 and info.len == 0) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig index 8d65d833e1349ab453a4bb61a74fb0757f9645b3..2b0cf5f472c789641bdf2cfe92fe7ca5a091c117 100644 --- a/test/cases/safety/exact division failure - vectors.zig +++ b/test/cases/safety/exact division failure - vectors.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .exact_division_remainder) { + if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig index 8fa31d6ee050a7265433f276b477bdcadf8669be..72179f312782bc8f5f5899953b032bda3c0bdaed 100644 --- a/test/cases/safety/exact division failure.zig +++ b/test/cases/safety/exact division failure.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .exact_division_remainder) { + if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig index 37a0761ee92e849ebff619a9642f97798d958b7c..17d43ab7f235d463951ed68ee1d9d2bb09aafc09 100644 --- a/test/cases/safety/for_len_mismatch.zig +++ b/test/cases/safety/for_len_mismatch.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .for_len_mismatch) { + if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig index 3f1f1ac23006a605c737f07151700597ae106135..16faaab1f9390f0b234ad077ea4ef4af57b0af3d 100644 --- a/test/cases/safety/for_len_mismatch_three.zig +++ b/test/cases/safety/for_len_mismatch_three.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .for_len_mismatch) { + if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig index 1ddb3588bccf6167dd7b3393fdd62846ead99afa..0552e47becb7f383b54a30292c81daa63e208d98 100644 --- a/test/cases/safety/ignored expression integer overflow.zig +++ b/test/cases/safety/ignored expression integer overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig index 8aea6c7616243e7687c3d81c91b4633c10f7bfa8..0195a5436ee24b8c892b20d73da205bc87ec146d 100644 --- a/test/cases/safety/integer addition overflow.zig +++ b/test/cases/safety/integer addition overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig index 3ac58efd313dda36ac5a890fbfa7808130d5396b..95dc075d6fbe66af382cf0c84c7e39a2f91cd3e6 100644 --- a/test/cases/safety/integer division by zero - vectors.zig +++ b/test/cases/safety/integer division by zero - vectors.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig index 7f14acc9a4b80a6119a3ed2d87839aac3f64041b..c2b083c7bd915c432d660ab4c95b31c626ab178b 100644 --- a/test/cases/safety/integer division by zero.zig +++ b/test/cases/safety/integer division by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig index d90d65ed86d6eb7e263d71e4ddc5e6384f212acf..1d194793a03ad16566bbdb563b535d973e38134c 100644 --- a/test/cases/safety/integer multiplication overflow.zig +++ b/test/cases/safety/integer multiplication overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig index 9a569b5338c8bbc0ee14aac40485fa2efa13dd7b..b37819e33b25689df8de4e56ae045fec1e9d347e 100644 --- a/test/cases/safety/integer negation overflow.zig +++ b/test/cases/safety/integer negation overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig index a6591dd9ec42d6b8007fd560d96d5f12002242c8..e44eebade3092251d5eac60c1d5e7c79e99e7503 100644 --- a/test/cases/safety/integer subtraction overflow.zig +++ b/test/cases/safety/integer subtraction overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/invalid resume of async function.zig b/test/cases/safety/invalid resume of async function.zig index c58f13b99d05389a8bf3dd34d98090190593539f..834ed75ef44f22cad4338319021c341735d2b9df 100644 --- a/test/cases/safety/invalid resume of async function.zig +++ b/test/cases/safety/invalid resume of async function.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/cases/safety/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig index 191a37f8eb77422e865734277581c6d168fe4684..a01a597d901ebc13390f20eebe88e2d021bd183a 100644 --- a/test/cases/safety/memcpy_alias.zig +++ b/test/cases/safety/memcpy_alias.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .memcpy_alias) { + if (std.mem.eql(u8, message, "@memcpy arguments alias")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig index aa5bb92732e817d8ed028c336f95c27c6d755c5f..943ddb582ce6f3e0b3036250eb3a36412925868c 100644 --- a/test/cases/safety/memcpy_len_mismatch.zig +++ b/test/cases/safety/memcpy_len_mismatch.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .memcpy_len_mismatch) { + if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig index c1c86df1aa54b4b7d82441b17e38ed7356036547..4347ba55e51406aa206900b2cd5b2b753e47c760 100644 --- a/test/cases/safety/memset_array_undefined_bytes.zig +++ b/test/cases/safety/memset_array_undefined_bytes.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig index 3cab2f4c5fcefdfe4cc8b24350007761ca1a1ef6..efbff0e9ce91a1d2a0885bbe636b3778f15a1962 100644 --- a/test/cases/safety/memset_array_undefined_large.zig +++ b/test/cases/safety/memset_array_undefined_large.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig index d6a7e3e5cd95f600f3f0b3286d118b9b0fab8c4c..08401efd591b0ab4c7b01640874ee780ba70b4f2 100644 --- a/test/cases/safety/memset_slice_undefined_bytes.zig +++ b/test/cases/safety/memset_slice_undefined_bytes.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig index a5e572eefdbe77c40cccc75535c62634d4400597..3f313109824363dcf930d410332ee131ea8b022e 100644 --- a/test/cases/safety/memset_slice_undefined_large.zig +++ b/test/cases/safety/memset_slice_undefined_large.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig index 16616f4801f9fe990cd3cba9923b4ad5d83b1b47..11949fb89667f0feabb3a0453b918056e2d0024d 100644 --- a/test/cases/safety/modrem by zero.zig +++ b/test/cases/safety/modrem by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig index 454b1cd432180cd0a1bc0aecbafa529b2cc898c0..9ddd96c4585b956c59a14d3d54945fa8ab1afbc2 100644 --- a/test/cases/safety/modulus by zero.zig +++ b/test/cases/safety/modulus by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn returned.zig index ac413089e77e3239f1bad1c38059908f8e1b704f..a6cf3e91ee5fbb577138284df4a28e9c87b40516 100644 --- a/test/cases/safety/noreturn returned.zig +++ b/test/cases/safety/noreturn returned.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .noreturn_returned) { + if (std.mem.eql(u8, message, "'noreturn' function returned")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/nosuspend function call, callee suspends.zig b/test/cases/safety/nosuspend function call, callee suspends.zig index 50f457f31458024c555d3a4c374ffb6e05cd67ac..f40dfc14b05af478c4f68294bd11cb6c15e7f3ca 100644 --- a/test/cases/safety/nosuspend function call, callee suspends.zig +++ b/test/cases/safety/nosuspend function call, callee suspends.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/cases/safety/optional unwrap operator on C pointer.zig b/test/cases/safety/optional unwrap operator on C pointer.zig index 59ffe381a483bffc5f8e0573eb05bba726bf48bc..da67bca3b9b06283cd79d9ef1e56d03f99957b8f 100644 --- a/test/cases/safety/optional unwrap operator on C pointer.zig +++ b/test/cases/safety/optional unwrap operator on C pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/optional unwrap operator on null pointer.zig b/test/cases/safety/optional unwrap operator on null pointer.zig index 9b09d63f7bbb59169199c7ecd6ab378eb528763d..3992f75ff3f5fbc92b91fbcbc244116216565f21 100644 --- a/test/cases/safety/optional unwrap operator on null pointer.zig +++ b/test/cases/safety/optional unwrap operator on null pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/out of bounds array slice by length.zig b/test/cases/safety/out of bounds array slice by length.zig index 9ad18972f84940a19d33bf3a7b43e8581c36abfe..3aef3eb425cefa43bf115505c911cbc5276d6041 100644 --- a/test/cases/safety/out of bounds array slice by length.zig +++ b/test/cases/safety/out of bounds array slice by length.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 16 and info.len == 5) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig index 7b7ac0f8fa26a1afeaa70a868719e9d247092d58..474be34db7be9f8c458b8e8e2341b62b80d305a6 100644 --- a/test/cases/safety/out of bounds slice access.zig +++ b/test/cases/safety/out of bounds slice access.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 4 and info.len == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/pointer casting null to non-optional pointer.zig b/test/cases/safety/pointer casting null to non-optional pointer.zig index ad8921ae92df79b2f438e197bd602627c0a42ab1..8f57156471090f3fe6ca0955e58c8a4d1d284d1c 100644 --- a/test/cases/safety/pointer casting null to non-optional pointer.zig +++ b/test/cases/safety/pointer casting null to non-optional pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/pointer casting to null function pointer.zig b/test/cases/safety/pointer casting to null function pointer.zig index 364f66ab1924cc7ba6888b7d594ec73d5ec545ee..13404b1a48ae7b1a920f8e15f101c8009dc826b6 100644 --- a/test/cases/safety/pointer casting to null function pointer.zig +++ b/test/cases/safety/pointer casting to null function pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_to_null) { + if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig index 7d79144fcf8ab0674622e302b4273d4d113a601a..a7a9eb94b670018ff13def56f0faf0ba627b33d5 100644 --- a/test/cases/safety/pointer slice sentinel mismatch.zig +++ b/test/cases/safety/pointer slice sentinel mismatch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .sentinel_mismatch_usize => |info| { - if (info.expected == 0 and info.found == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig index 9fee0aa13ac5231d92fb46dd40b110772456ca5a..8681970a4ba7d840c9c1c1cd468b6f7e0e0e6360 100644 --- a/test/cases/safety/remainder division by zero.zig +++ b/test/cases/safety/remainder division by zero.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .divide_by_zero) { + if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/resuming a function which is awaiting a call.zig b/test/cases/safety/resuming a function which is awaiting a call.zig index 47545584eaf19b95d65c209462fc9fde2896bd3b..0e101594be8daa83675094c1cf6738c5ae506af5 100644 --- a/test/cases/safety/resuming a function which is awaiting a call.zig +++ b/test/cases/safety/resuming a function which is awaiting a call.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/cases/safety/resuming a function which is awaiting a frame.zig b/test/cases/safety/resuming a function which is awaiting a frame.zig index 26df1ae900b470e279f6aa35a53d96dab9cee0f6..d005e31cd8da02401583f07b1dc1ccea7ca110cf 100644 --- a/test/cases/safety/resuming a function which is awaiting a frame.zig +++ b/test/cases/safety/resuming a function which is awaiting a frame.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig b/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig index f8bf6d44c08f8551d6ce6311eea2af8ec6f679fa..931d4de3e08938e481dc5cca2c6202e4928f1b0a 100644 --- a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig +++ b/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/cases/safety/resuming a non-suspended function which never been suspended.zig b/test/cases/safety/resuming a non-suspended function which never been suspended.zig index af288ab8ba398d2d603bb4336a81721b8ae7d6c5..fb7d97b8ffe2a401a3aeec5043c716c190110aab 100644 --- a/test/cases/safety/resuming a non-suspended function which never been suspended.zig +++ b/test/cases/safety/resuming a non-suspended function which never been suspended.zig @@ -1,6 +1,16 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/cases/safety/shift left by huge amount.zig b/test/cases/safety/shift left by huge amount.zig index 09425b2cc1d2ac87ba699e477788febd3c85fd64..01b40e0bfc35ada9a89a6d47c8760a4130f5da4a 100644 --- a/test/cases/safety/shift left by huge amount.zig +++ b/test/cases/safety/shift left by huge amount.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shift_rhs_too_big) { + if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig index b02e2a01af27d2c1fba55aa8536ffd273ce51c23..7ef33ddb36a5df2731109a9f6ba993257c4fc8c4 100644 --- a/test/cases/safety/shift right by huge amount.zig +++ b/test/cases/safety/shift right by huge amount.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shift_rhs_too_big) { + if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig index 0da140b8f2debddd2a4400016b1defe8baab3532..623e1eac2174a361a4e08a22eca9bb59da4b155a 100644 --- a/test/cases/safety/signed integer division overflow - vectors.zig +++ b/test/cases/safety/signed integer division overflow - vectors.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig index 576e3ef7aa50e32547e1762e1cfe0bcb12c4957c..df805db4d944c88438f2b3562c1a7b948659a67b 100644 --- a/test/cases/safety/signed integer division overflow.zig +++ b/test/cases/safety/signed integer division overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig index 762719df81656eda302048ab30552bdd8758b182..a446cde23a620822fd4c1a940d7a558e12369d96 100644 --- a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig +++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .negative_to_unsigned) { + if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig index 765a50d5a562dcee013f0f9b5f15efb70fbd89a4..b839b36a2247a5a3398d8525cf5837ffe74540ca 100644 --- a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig +++ b/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .negative_to_unsigned) { + if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig index 148d79ca4d61f6f9fa89f71c3723e758c337cb45..5f9cb3aaceeffe6c3a427971fd88daad23fe8c68 100644 --- a/test/cases/safety/signed shift left overflow.zig +++ b/test/cases/safety/signed shift left overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shl_overflow) { + if (std.mem.eql(u8, message, "left shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig index f89f57a132a6d0010be260a904daf05d77a51c4e..c65a361da5eef5f5371959fae7ff51852c4b66f3 100644 --- a/test/cases/safety/signed shift right overflow.zig +++ b/test/cases/safety/signed shift right overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shr_overflow) { + if (std.mem.eql(u8, message, "right shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig index 2dee04d1bfa85a495fde9e6d669788a13cf94322..34f540ddb0383f2a910e596a49d1c98eb25e9715 100644 --- a/test/cases/safety/signed-unsigned vector cast.zig +++ b/test/cases/safety/signed-unsigned vector cast.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .negative_to_unsigned) { + if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig index 71b32e0c8a50f7b311e6fff0ea4816a040824e57..11ce2ff321c540ba50953347f6fa2ec30bb5e2da 100644 --- a/test/cases/safety/slice sentinel mismatch - floats.zig +++ b/test/cases/safety/slice sentinel mismatch - floats.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .sentinel_mismatch_other) { + if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig index 5e69a1d3503260ef377753f07407ac19904f38b1..6e0766dfbe777e99e465452de652691c0258b29b 100644 --- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig +++ b/test/cases/safety/slice sentinel mismatch - optional pointers.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .sentinel_mismatch_other) { + if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig index 7f90b9edbfa4a9b4fd69caf8399ccf92545b7404..58f80bd11be24781d0f415a18119af847f8481d1 100644 --- a/test/cases/safety/slice slice sentinel mismatch.zig +++ b/test/cases/safety/slice slice sentinel mismatch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .sentinel_mismatch_usize => |info| { - if (info.expected == 0 and info.found == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/slice start index greater than end index.zig b/test/cases/safety/slice start index greater than end index.zig index 5cdf1e46e9471759477a402888ce697ea426b3e1..55589c86847c2a7e6a6f180240da585ba6c19bbc 100644 --- a/test/cases/safety/slice start index greater than end index.zig +++ b/test/cases/safety/slice start index greater than end index.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .start_index_greater_than_end => |info| { - if (info.start == 10 and info.end == 1) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig index 09d8fa32a5795aa0acdcee5be6e1c224822248e4..80afb81f60c00b51b5c6410997cb2f81f60e0d93 100644 --- a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig +++ b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 5 and info.len == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig index 1ec06986576715e66fb61c31137a03873a9d01e6..d36cb7141ab4464b44002f39ba301732a26d28c7 100644 --- a/test/cases/safety/slice with sentinel out of bounds.zig +++ b/test/cases/safety/slice with sentinel out of bounds.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .index_out_of_bounds => |info| { - if (info.index == 5 and info.len == 4) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/slicing null C pointer - runtime len.zig b/test/cases/safety/slicing null C pointer - runtime len.zig index d4ebbdff18fd35a7ec16d5735e8024d9425b2483..7886121378a9aa03138b0a5b023a700ccc0d8be8 100644 --- a/test/cases/safety/slicing null C pointer - runtime len.zig +++ b/test/cases/safety/slicing null C pointer - runtime len.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig index b3e50b0ebf1e7d3f203888c0aeada4ac28da1980..502c7a1bbbbd794d8c88cfc2f7d3ea0fb53763db 100644 --- a/test/cases/safety/slicing null C pointer.zig +++ b/test/cases/safety/slicing null C pointer.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .unwrap_null) { + if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value - one prong.zig b/test/cases/safety/switch else on corrupt enum value - one prong.zig index bc8321a346935693bf5b682b1fa0ffacf8d5a8b2..7e1e8dfce205a6ce4e04f97130afe764a48f9e3b 100644 --- a/test/cases/safety/switch else on corrupt enum value - one prong.zig +++ b/test/cases/safety/switch else on corrupt enum value - one prong.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value - union.zig b/test/cases/safety/switch else on corrupt enum value - union.zig index 4f6e00c85a0a208936788c8ecb1c5f784848c379..b6781682d7b522c6c5c78889c072ea5b2ebc9003 100644 --- a/test/cases/safety/switch else on corrupt enum value - union.zig +++ b/test/cases/safety/switch else on corrupt enum value - union.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch else on corrupt enum value.zig b/test/cases/safety/switch else on corrupt enum value.zig index 1d382173992091e80a1c6b632a8abf0a8d051853..b06dec9168bcbabb8e5b624b03404f41f458a285 100644 --- a/test/cases/safety/switch else on corrupt enum value.zig +++ b/test/cases/safety/switch else on corrupt enum value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig index 159140180881d7f0cee778e4fafba64ae3a21b18..23f288432906a9c602c697247153ec78f5ba049f 100644 --- a/test/cases/safety/switch on corrupted enum value.zig +++ b/test/cases/safety/switch on corrupted enum value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig index 1ae72fcbfbf3b66b8d4a7a138dbe7412f4d6fa86..1829d3104f9fde9849e1e63aef21a7115deb5360 100644 --- a/test/cases/safety/switch on corrupted union value.zig +++ b/test/cases/safety/switch on corrupted union value.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .corrupt_switch) { + if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig index 32fb407555974b5236008155c17a6e35e4b89102..e68b029c3332bb3e524fd26d6073b62529faff43 100644 --- a/test/cases/safety/truncating vector cast.zig +++ b/test/cases/safety/truncating vector cast.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig index b12b1a722f888724992aa1ab76e0a1a0ea6ba308..bb55a01cfe715fe9866ddcea79c946cd708e19bf 100644 --- a/test/cases/safety/unreachable.zig +++ b/test/cases/safety/unreachable.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .reached_unreachable) { + if (std.mem.eql(u8, message, "reached unreachable code")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig index 937d5225691536e2522d931b634d27369fac341c..399e66c21691f45522ff04e722974acc41ceef5c 100644 --- a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig +++ b/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig index 53fe91c9fb98592b790de9a724df375ee7ea6f0f..b7d1ffe09b64f856ad6b8492345a346c98b3823e 100644 --- a/test/cases/safety/unsigned shift left overflow.zig +++ b/test/cases/safety/unsigned shift left overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shl_overflow) { + if (std.mem.eql(u8, message, "left shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig index a5389797fc3be05839a6d354665d81157f40fc4a..aa5fbf493cafb1b49706cf9c1b66e60ee2e89b30 100644 --- a/test/cases/safety/unsigned shift right overflow.zig +++ b/test/cases/safety/unsigned shift right overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .shr_overflow) { + if (std.mem.eql(u8, message, "right shift overflowed bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig index aab2f5ae168a1ea9369a4ae51f8ba79a0b2da2e9..1599eb045f64ecb3d31a74265277bee9e0979201 100644 --- a/test/cases/safety/unsigned-signed vector cast.zig +++ b/test/cases/safety/unsigned-signed vector cast.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig index dd587c48653c5a32426bbbedba062e33a9121423..9661efddddec8e766334a99f8a42c39b89185e9d 100644 --- a/test/cases/safety/unwrap error switch.zig +++ b/test/cases/safety/unwrap error switch.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .unwrap_error => |err| { - if (err == error.Whatever) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig index a2ac8f50461c19d27255cc2d42d455cbdd8a91e8..f4284724624477125dbeab512632acd83abc1df2 100644 --- a/test/cases/safety/unwrap error.zig +++ b/test/cases/safety/unwrap error.zig @@ -1,14 +1,19 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - switch (cause) { - .unwrap_error => |err| { - if (err == error.Whatever) { - std.process.exit(0); - } - }, - else => {}, + if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { + std.process.exit(0); } std.process.exit(1); } diff --git a/test/cases/safety/value does not fit in shortening cast - u0.zig b/test/cases/safety/value does not fit in shortening cast - u0.zig index d06d1cf440d4ae4439be05c5a80eff544757611d..e6a4d84135f520d564d74d4a8ee12e38da7bc8fe 100644 --- a/test/cases/safety/value does not fit in shortening cast - u0.zig +++ b/test/cases/safety/value does not fit in shortening cast - u0.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/value does not fit in shortening cast.zig b/test/cases/safety/value does not fit in shortening cast.zig index 3f55f40f963efab093adc9edd8f4dbd6e7e8953c..f2eaf3fd6e240831bca38e9ff932dc186fb0ff87 100644 --- a/test/cases/safety/value does not fit in shortening cast.zig +++ b/test/cases/safety/value does not fit in shortening cast.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .cast_truncated_data) { + if (std.mem.eql(u8, message, "integer cast truncated bits")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig index 3e3145db862da53af946766bad333afe7e1faa59..8cb936b2c7b5403ebfabb7deb56d5bf26452a95a 100644 --- a/test/cases/safety/vector integer addition overflow.zig +++ b/test/cases/safety/vector integer addition overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig index eceb507efa16630efc9875324196468daf06e028..d3ae414bf62d32950afff395559209e25a3791a1 100644 --- a/test/cases/safety/vector integer multiplication overflow.zig +++ b/test/cases/safety/vector integer multiplication overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig index 5f408dab8b6d73b9f22f280d19a36dc372715c23..3c84df786a92dad93ab0d173fb62df5831c23e07 100644 --- a/test/cases/safety/vector integer negation overflow.zig +++ b/test/cases/safety/vector integer negation overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig index c858ac5e341fd006d4fc2b69d2a61fe5265cb255..dd34dd11e7d92b353c4bf87e7936814beb497f91 100644 --- a/test/cases/safety/vector integer subtraction overflow.zig +++ b/test/cases/safety/vector integer subtraction overflow.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .integer_overflow) { + if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); } std.process.exit(1); diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig index 591e4b62ef9eae8d9e6fc4f2888dd270f4b0870c..83f93622ce39ed1d3b3cddd0a393c972c41b73ea 100644 --- a/test/cases/safety/zero casted to error.zig +++ b/test/cases/safety/zero casted to error.zig @@ -1,8 +1,18 @@ const std = @import("std"); -pub fn panic(cause: std.builtin.PanicCause, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub const Panic = struct { + pub const call = panic; + pub const unwrapError = std.debug.FormattedPanic.unwrapError; + pub const outOfBounds = std.debug.FormattedPanic.outOfBounds; + pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd; + pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch; + pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField; + pub const messages = std.debug.FormattedPanic.messages; +}; + +fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; - if (cause == .invalid_error_code) { + if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); } std.process.exit(1); -- 2.54.0