simplify the panic handler function to be only one function; remove `-fformatted-panics`

[andrewrk]

There should only be 1 panic handler function and it should be possible to override it by only providing one function. Furthermore, it should be the entry point from the language; there should be no other dependencies on the std lib such as formatted printing.

It should look something like this:

pub const PanicCause = union(enum) {
    unreach,
    unwrap_null,
    cast_to_null,
    incorrect_alignment,
    out_of_bounds: struct {
        index: usize,
        len: usize,
    },
    sentinel_mismatch_usize: usize,
    sentinel_mismatch_isize: isize,
    sentinel_mismatch_other,
    /// This one comes from a call to `@panic`.
    application_msg: []const u8,
    // ...
};

pub fn panic(cause: PanicCause, error_return_trace: ?*StackTrace, ret_addr: ?usize) noreturn {
    // ...
}

This provides complete flexibility to the application overriding the default handler, while keeping it to a single function to be overridden.

[amp-59]

Reporting non-scalar sentinels can not work with the solution you have suggested.

[amp-59]

@andrewrk The incompatibility with non-scalar sentinels is this:

• The return type of the single function is noreturn.
• Non-scalar sentinels require generic test code (meta.eql) to be compiled within the panic function as with the existing function (checkNonScalarSentinel). If the expected and found values are equal the function returns, so the return type must be void.
• Non-scalar sentinels require an anytype renderer to represent the difference between found and expected values in case of a panic.

[AssortedFantasy]

How about also adding an argument containing the std.builtin.SourceLocation?
So a signature more like this:

pub fn panic(cause: PanicCause, error_return_trace: ?*StackTrace, ret_addr: ?usize, source: ?std.builtin.SourceLocation ) noreturn {
    // ...
}

This would let a basic panic handler at least point to where the panic happened even if you don't want to get into std.debug.DebugInfo and std.debug.dumpStackTrace.

[amp-59]

How about also adding an argument containing the std.builtin.SourceLocation?

That is a large additional cost for common checked arithmetic operations, such as addition, subtraction, and multiplication. Each occurrence of these operations in source would probably cost an additional 64 bytes in program segments; 16 in .text, 48 in .rodata:

fn useSrcLoc(src: ?zl.builtin.SourceLocation) void {
    if (src) |_| {}
}
pub fn main() void {}

Simulating just the call with @src():

fn useSrcLoc(src: ?zl.builtin.SourceLocation) void {
    if (src) |_| {}
}
pub fn main() void {
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
    useSrcLoc(@src());
}

In a real program the cost would be higher, as the strings for fn_name and file are reused in the example.

[AssortedFantasy]

Why wouldn't the function name and file be reused? Surely it could be done smartly so its only whatever bytes for the function name and the file name and then per each instance of a call to panic you only need the u32 for line and u32 for column?

[xdBronch]

Why wouldn't the function name and file be reused?

because it wont always be called from the same function and file

[AssortedFantasy]

Here is an example of what I mean. This is roughly how the panic could work at the implementation level. Not embedding the full source struct in every panic location.

const std = @import("std");
const SourceLocation = std.builtin.SourceLocation;

fn panicImpl(src: SourceLocation) noreturn {
    _ = src;
    @panic("");
}

fn panic_zig_file(partial: SourceLocation) noreturn {
    panicImpl(.{
        .file = "main.zig", // One copy only
        .fn_name = partial.fn_name,
        .column = partial.column,
        .line = partial.line,
    });
}

fn panic_main_fn(line: u32, column: u32) noreturn {
    panic_zig_file(.{
        .file = undefined,
        .fn_name = "main", // One per function
        .column = column,
        .line = line,
    });
}

pub fn main() !void {
    panic_main_fn(30, 5);
    panic_main_fn(31, 5);
    panic_main_fn(32, 5);
    panic_main_fn(33, 5);
    panic_main_fn(34, 5);
    panic_main_fn(35, 5);
    panic_main_fn(36, 5);
    panic_main_fn(37, 5);
    panic_main_fn(38, 5);
    panic_main_fn(39, 5);
    panic_main_fn(40, 5);
    panic_main_fn(41, 5);
    panic_main_fn(42, 5);
    panic_main_fn(43, 5);
    panic_main_fn(44, 5);
    panic_main_fn(45, 5);
}