commit ac207073f3426e615e7d4735994f73f67af7ee8e (tree) parent cbd7f54f06e788f54573dbbe261b9defad32020b Author: Mason Remaley <mason@gamesbymason.com> Date: Sat, 11 Apr 2026 16:04:57 -0700 Reverts renaming of builtin.StackTrace -> ErrorReturnTrace We can defer this change until the next time zig1 needs to be updated Diffstat:
117 files changed, 142 insertions(+), 141 deletions(-)
diff --git a/doc/langref.html.in b/doc/langref.html.in @@ -4900,7 +4900,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val {#header_close#} {#header_open|@errorReturnTrace#} - <pre>{#syntax#}@errorReturnTrace() ?*builtin.ErrorReturnTrace{#endsyntax#}</pre> + <pre>{#syntax#}@errorReturnTrace() ?*builtin.StackTrace{#endsyntax#}</pre> <p> If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a diff --git a/lib/build-web/main.zig b/lib/build-web/main.zig @@ -40,7 +40,7 @@ pub const std_options: std.Options = .{ .logFn = logFn, }; -pub fn panic(msg: []const u8, st: ?*std.debug.StackTrace, addr: ?usize) noreturn { +pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noreturn { _ = st; _ = addr; log.err("panic: {s}", .{msg}); diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig @@ -33,7 +33,7 @@ pub const std_options: std.Options = .{ //.log_level = .debug, }; -pub fn panic(msg: []const u8, st: ?*std.debug.StackTrace, addr: ?usize) noreturn { +pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noreturn { _ = st; _ = addr; log.err("panic: {s}", .{msg}); diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig @@ -8,7 +8,7 @@ pub const assembly = @import("builtin/assembly.zig"); /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. -pub const ErrorReturnTrace = struct { +pub const StackTrace = struct { index: usize, instruction_addresses: []usize, }; diff --git a/lib/std/debug.zig b/lib/std/debug.zig @@ -816,7 +816,7 @@ pub const FormatStackTrace = struct { }; /// Write a previously captured error return trace to `writer`, annotated with source locations. -pub fn writeErrorReturnTrace(et: *const std.builtin.ErrorReturnTrace, t: Io.Terminal) Writer.Error!void { +pub fn writeErrorReturnTrace(et: *const std.builtin.StackTrace, t: Io.Terminal) Writer.Error!void { // We take the slice by value, preventing the length from being mutated if an error occurs while // writing the stack trace. const len = @min(et.instruction_addresses.len, et.index); @@ -885,7 +885,7 @@ pub fn dumpStackTrace(st: *const StackTrace) void { } /// A thin wrapper around `writeErrorReturnTrace` which writes to stderr and ignores write errors. -pub fn dumpErrorReturnTrace(et: *const std.builtin.ErrorReturnTrace) void { +pub fn dumpErrorReturnTrace(et: *const std.builtin.StackTrace) void { const stderr = lockStderr(&.{}).terminal(); defer unlockStderr(); writeErrorReturnTrace(et, stderr) catch |err| switch (err) { diff --git a/src/Sema.zig b/src/Sema.zig @@ -2252,8 +2252,9 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize) }); const addrs_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(addr_arr_ty)); - const error_return_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .ErrorReturnTrace); - const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(error_return_trace_ty)); + // var st: StackTrace = undefined; + const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace); + const st_ptr = try err_trace_block.addTy(.alloc, try pt.singleMutPtrType(stack_trace_ty)); // st.instruction_addresses = &addrs; const instruction_addresses_field_name = try ip.getOrPutString(gpa, io, pt.tid, "instruction_addresses", .no_embedded_nulls); @@ -6165,10 +6166,10 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref if (!block.ownerModule().error_tracing) return .none; - const error_return_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .ErrorReturnTrace); + const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); - const field_index = sema.structFieldIndex(block, error_return_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) { - error.AnalysisFail => @panic("std.builtin.ErrorReturnTrace is corrupt"), + const field_index = sema.structFieldIndex(block, stack_trace_ty, field_name, LazySrcLoc.unneeded) catch |err| switch (err) { + error.AnalysisFail => @panic("std.builtin.StackTrace is corrupt"), error.ComptimeReturn, error.ComptimeBreak => unreachable, error.OutOfMemory, error.Canceled => |e| return e, }; @@ -6176,7 +6177,7 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref return try block.addInst(.{ .tag = .save_err_return_trace_index, .data = .{ .ty_pl = .{ - .ty = Air.internedToRef(error_return_trace_ty.toIntern()), + .ty = Air.internedToRef(stack_trace_ty.toIntern()), .payload = @intCast(field_index), } }, }); @@ -6208,11 +6209,11 @@ fn popErrorReturnTrace( // AstGen determined this result does not go to an error-handling expr (try/catch/return etc.), or // the result is comptime-known to be a non-error. Either way, pop unconditionally. - const error_return_trace_ty = try sema.getBuiltinType(src, .ErrorReturnTrace); - const ptr_error_return_trace_ty = try pt.singleMutPtrType(error_return_trace_ty); - const err_return_trace = try block.addTy(.err_return_trace, ptr_error_return_trace_ty); + const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace); + const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); + const err_return_trace = try block.addTy(.err_return_trace, ptr_stack_trace_ty); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); - const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, error_return_trace_ty); + const field_ptr = try sema.structFieldPtr(block, src, err_return_trace, field_name, src, stack_trace_ty); try sema.storePtr2(block, src, field_ptr, src, saved_error_trace_index, src, .store); } else if (is_non_error == null) { // The result might be an error. If it is, we leave the error trace alone. If it isn't, we need @@ -6233,11 +6234,11 @@ fn popErrorReturnTrace( defer then_block.instructions.deinit(gpa); // If non-error, then pop the error return trace by restoring the index. - const error_return_trace_ty = try sema.getBuiltinType(src, .ErrorReturnTrace); - const ptr_error_return_trace_ty = try pt.singleMutPtrType(error_return_trace_ty); - const err_return_trace = try then_block.addTy(.err_return_trace, ptr_error_return_trace_ty); + const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace); + const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); + const err_return_trace = try then_block.addTy(.err_return_trace, ptr_stack_trace_ty); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); - const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, error_return_trace_ty); + const field_ptr = try sema.structFieldPtr(&then_block, src, err_return_trace, field_name, src, stack_trace_ty); try sema.storePtr2(&then_block, src, field_ptr, src, saved_error_trace_index, src, .store); _ = try then_block.addBr(cond_block_inst, .void_value); @@ -6372,15 +6373,15 @@ fn zirCall( // If any input is an error-type, we might need to pop any trace it generated. Otherwise, we only // need to clean-up our own trace if we were passed to a non-error-handling expression. if (input_is_error or (pop_error_return_trace and return_ty.isError(zcu))) { - const error_return_trace_ty = try sema.getBuiltinType(call_src, .ErrorReturnTrace); + const stack_trace_ty = try sema.getBuiltinType(call_src, .StackTrace); const field_name = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, "index", .no_embedded_nulls); - const field_index = try sema.structFieldIndex(block, error_return_trace_ty, field_name, call_src); + const field_index = try sema.structFieldIndex(block, stack_trace_ty, field_name, call_src); // Insert a save instruction before the arg resolution + call instructions we just generated const save_inst = try block.insertInst(block_index, .{ .tag = .save_err_return_trace_index, .data = .{ .ty_pl = .{ - .ty = Air.internedToRef(error_return_trace_ty.toIntern()), + .ty = Air.internedToRef(stack_trace_ty.toIntern()), .payload = @intCast(field_index), } }, }); @@ -19528,13 +19529,13 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const error_return_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .ErrorReturnTrace); - const ptr_error_return_trace_ty = try pt.singleMutPtrType(error_return_trace_ty); - const opt_ptr_error_return_trace_ty = try pt.optionalType(ptr_error_return_trace_ty.toIntern()); + const stack_trace_ty = try sema.getBuiltinType(block.nodeOffset(.zero), .StackTrace); + const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty); + const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern()); switch (sema.owner.unwrap()) { .func => |func| if (ip.funcAnalysisUnordered(func).has_error_trace and block.ownerModule().error_tracing) { - return block.addTy(.err_return_trace, opt_ptr_error_return_trace_ty); + return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty); }, .@"comptime", @@ -19546,7 +19547,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref { => {}, } return Air.internedToRef(try pt.intern(.{ .opt = .{ - .ty = opt_ptr_error_return_trace_ty.toIntern(), + .ty = opt_ptr_stack_trace_ty.toIntern(), .val = .none, } })); } diff --git a/src/Zcu.zig b/src/Zcu.zig @@ -434,7 +434,7 @@ pub const BuiltinDecl = enum { AddressSpace, CallingConvention, returnError, - ErrorReturnTrace, + StackTrace, SourceLocation, CallModifier, AtomicOrder, @@ -512,7 +512,7 @@ pub const BuiltinDecl = enum { return switch (decl) { .returnError => .func, - .ErrorReturnTrace, + .StackTrace, .CallingConvention, .SourceLocation, .Signedness, diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig @@ -3374,7 +3374,7 @@ pub const Object = struct { } if (fn_info.cc == .auto and zcu.comp.config.any_error_tracing) { - // First parameter is a pointer to `std.builtin.ErrorReturnTrace`. + // First parameter is a pointer to `std.builtin.StackTrace`. const llvm_ptr_ty = try o.builder.ptrType(toLlvmAddressSpace(.generic, target)); try llvm_params.append(o.gpa, llvm_ptr_ty); } diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig @@ -6,7 +6,7 @@ export fn foo() void { @panic("oh no"); } -pub fn panic(_: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { @compileError("panic"); } diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/@alignCast misaligned.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "incorrect alignment")) { 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); diff --git a/test/cases/safety/@enumFromInt truncated bits - exhaustive.zig b/test/cases/safety/@enumFromInt truncated bits - exhaustive.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } diff --git a/test/cases/safety/@enumFromInt truncated bits - nonexhaustive.zig b/test/cases/safety/@enumFromInt truncated bits - nonexhaustive.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); } diff --git a/test/cases/safety/@errorCast error not present in destination.zig b/test/cases/safety/@errorCast error not present in destination.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/@intCast to u0.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 max.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - i0 min.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - signed max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - signed max.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - signed min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - signed min.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 max.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - u0 min.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned max.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - unsigned min.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - vector max.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - vector max.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - boundary case - vector min.zig b/test/cases/safety/@intFromFloat cannot fit - boundary case - vector min.zig @@ -1,5 +1,5 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); diff --git a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/@ptrFromInt with misaligned address.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "incorrect alignment")) { std.process.exit(0); diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/@tagName on corrupted enum value.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/@tagName on corrupted union value.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "invalid enum value")) { std.process.exit(0); diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) { std.process.exit(0); diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { std.process.exit(0); diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad union field access.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) { std.process.exit(0); diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "oh no")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) { std.process.exit(0); diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact division failure - vectors.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact division failure.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "exact division produced remainder")) { std.process.exit(0); diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { std.process.exit(0); diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer addition overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer division by zero - vectors.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer division by zero.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer multiplication overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer negation overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer subtraction overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "@memcpy arguments alias")) { std.process.exit(0); diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "source and destination arguments have non-equal lengths")) { std.process.exit(0); diff --git a/test/cases/safety/memmove_len_mismatch.zig b/test/cases/safety/memmove_len_mismatch.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "source and destination arguments have non-equal lengths")) { std.process.exit(0); diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem by zero.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus by zero.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "division by zero")) { std.process.exit(0); diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn returned.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "'noreturn' function returned")) { 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); diff --git a/test/cases/safety/optional unwrap operator on null pointer.zig b/test/cases/safety/optional unwrap operator on null pointer.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); diff --git a/test/cases/safety/optional_empty_error_set.zig b/test/cases/safety/optional_empty_error_set.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, ra: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, ra: ?usize) noreturn { _ = stack_trace; _ = ra; if (std.mem.eql(u8, message, "attempt to use null value")) { 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) { std.process.exit(0); diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out of bounds slice access.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); diff --git a/test/cases/safety/pointer casting to null function pointer.zig b/test/cases/safety/pointer casting to null function pointer.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "cast causes pointer to be null")) { std.process.exit(0); diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer slice sentinel mismatch.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { std.process.exit(0); diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder division by zero.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "division by zero")) { 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { std.process.exit(0); diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift right by huge amount.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { std.process.exit(0); diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed integer division overflow - vectors.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed integer division overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed shift left overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "left shift overflowed bits")) { std.process.exit(0); diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed shift right overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "right shift overflowed bits")) { std.process.exit(0); diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned vector cast.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); diff --git a/test/cases/safety/slice by length sentinel mismatch on lhs.zig b/test/cases/safety/slice by length sentinel mismatch on lhs.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected 1, found 3")) { std.process.exit(0); diff --git a/test/cases/safety/slice by length sentinel mismatch on rhs.zig b/test/cases/safety/slice by length sentinel mismatch on rhs.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected 1, found 0")) { std.process.exit(0); diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice sentinel mismatch - floats.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2, found 4")) { std.process.exit(0); diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice sentinel mismatch - optional pointers.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) { std.process.exit(0); diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice slice sentinel mismatch.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { std.process.exit(0); diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice with sentinel out of bounds.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { std.process.exit(0); diff --git a/test/cases/safety/slice_cast_change_len_0.zig b/test/cases/safety/slice_cast_change_len_0.zig @@ -13,7 +13,7 @@ pub fn main() void { std.process.exit(1); } -pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { if (std.mem.eql(u8, message, "slice length '3' does not divide exactly into destination elements")) { std.process.exit(0); } diff --git a/test/cases/safety/slice_cast_change_len_1.zig b/test/cases/safety/slice_cast_change_len_1.zig @@ -13,7 +13,7 @@ pub fn main() void { std.process.exit(1); } -pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { if (std.mem.eql(u8, message, "slice length '1' does not divide exactly into destination elements")) { std.process.exit(0); } diff --git a/test/cases/safety/slice_cast_change_len_2.zig b/test/cases/safety/slice_cast_change_len_2.zig @@ -13,7 +13,7 @@ pub fn main() void { std.process.exit(1); } -pub fn panic(message: []const u8, _: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { if (std.mem.eql(u8, message, "slice length '1' does not divide exactly into destination elements")) { std.process.exit(0); } diff --git a/test/cases/safety/slicing null C pointer - runtime len.zig b/test/cases/safety/slicing null C pointer - runtime len.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing null C pointer.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "attempt to use null value")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); diff --git a/test/cases/safety/switch else on corrupt enum value.zig b/test/cases/safety/switch else on corrupt enum value.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch on corrupted enum value.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch on corrupted union value.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "switch on corrupt value")) { std.process.exit(0); diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating vector cast.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "reached unreachable code")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned shift left overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "left shift overflowed bits")) { std.process.exit(0); diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned shift right overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "right shift overflowed bits")) { std.process.exit(0); diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed vector cast.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap error switch.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { std.process.exit(0); diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap error.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); 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 @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer does not fit in destination type")) { std.process.exit(0); diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector integer addition overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector integer multiplication overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector integer negation overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector integer subtraction overflow.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "integer overflow")) { std.process.exit(0); diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig @@ -1,6 +1,6 @@ const std = @import("std"); -pub fn panic(message: []const u8, stack_trace: ?*std.debug.StackTrace, _: ?usize) noreturn { +pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { _ = stack_trace; if (std.mem.eql(u8, message, "invalid error code")) { std.process.exit(0); diff --git a/test/cases/tail_call_noreturn.zig b/test/cases/tail_call_noreturn.zig @@ -1,9 +1,9 @@ const std = @import("std"); const builtin = std.builtin; -pub fn foo(message: []const u8, stack_trace: ?*std.debug.StackTrace) noreturn { +pub fn foo(message: []const u8, stack_trace: ?*builtin.StackTrace) noreturn { @call(.always_tail, bar, .{ message, stack_trace }); } -pub fn bar(message: []const u8, stack_trace: ?*std.debug.StackTrace) noreturn { +pub fn bar(message: []const u8, stack_trace: ?*builtin.StackTrace) noreturn { _ = message; _ = stack_trace; std.process.exit(0); diff --git a/test/standalone/compile_asm/main.zig b/test/standalone/compile_asm/main.zig @@ -4,7 +4,7 @@ export fn main(r0: u32, r1: u32, atags: u32) callconv(.c) noreturn { _ = atags; unreachable; // never gets run so it doesn't matter } -pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").debug.StackTrace, _: ?usize) noreturn { +pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").builtin.StackTrace, _: ?usize) noreturn { _ = msg; _ = error_return_trace; while (true) {} diff --git a/test/standalone/issue_339/test.zig b/test/standalone/issue_339/test.zig @@ -1,4 +1,4 @@ -const StackTrace = @import("std").debug.StackTrace; +const StackTrace = @import("std").builtin.StackTrace; pub fn panic(msg: []const u8, stack_trace: ?*StackTrace, _: ?usize) noreturn { _ = msg; _ = stack_trace; diff --git a/test/tests.zig b/test/tests.zig @@ -2291,7 +2291,7 @@ pub fn addCliTests(b: *std.Build) *Step { \\ return num * num; \\} \\extern fn zig_panic() noreturn; - \\pub fn panic(msg: []const u8, error_return_trace: ?*@import("std").debug.StackTrace, _: ?usize) noreturn { + \\pub fn panic(msg: []const u8, error_return_trace: ?*@import("builtin").StackTrace, _: ?usize) noreturn { \\ _ = msg; \\ _ = error_return_trace; \\ zig_panic();