Show source code in stack traces

[HKalbasi]

Inspired by Zig, I would like to see source code snippets in the stack trace generated when panicking.

This Zig code:

fn foo(n: usize) i32 {
    const a = [3]i32{ 1, 2, 3 };
    return a[n];
}

pub fn main() void {
    _ = foo(5);
}

Generates this stack trace:

thread 224036 panic: index out of bounds: index 5, len 3
/home/hamid/zig-playground/main.zig:3:13: 0x113fac1 in foo (main.zig)
    return a[n];
            ^
/home/hamid/zig-playground/main.zig:7:12: 0x113e851 in main (main.zig)
    _ = foo(5);
           ^
/home/hamid/.local/share/mise/installs/zig/0.15.1/lib/std/start.zig:618:22: 0x113da9d in posixCallMainAndExit (std.zig)
            root.main();
                     ^

Showing the source code in the stack trace enables quickly understanding the scope and reason of the problem, without needing to lookup the line numbers in the source code. It is especially helpful when the source code has drifted and line numbers are not in sync with the current code.

This is not specific to Zig, other languages also have this feature. For example Python:

Traceback (most recent call last):
  File "/home/hamid/zig-playground/main.py", line 5, in <module>
    foo(5)
    ~~~^^^
  File "/home/hamid/zig-playground/main.py", line 3, in foo
    return a[n]
           ~^^^
IndexError: list index out of range

or Go:

panic: runtime error: index out of range [5] with length 3

goroutine 1 [running]:
main.foo(...)
        /home/hamid/zig-playground/main.go:5
main.main()
        /home/hamid/zig-playground/main.go:9 +0x18
exit status 2

What makes Zig particularly interesting to me, is that it's a low level language similar to Rust with no runtime. If Zig could afford this feature, Rust probably can as well.

[hanna-kruppe]

Aside from any changes to the backtrace machinery this may require, this part:

It is especially helpful when the source code has drifted and line numbers are not in sync with the current code.

… requires embedding the source code at the time of build in the binary. This is possible in DWARF v5 and rustc has an unstable flag for doing it: rust-lang/compiler-team#764 (doesn’t see to have a tracking issue)

If this flag was turned on by default, we’d probably need to stabilize the flag first so people can opt out if they don’t want it.

[workingjubilee]

Obligatory question of: "Is that what Zig actually does, or does it just access things off disk?"

[bjorn3]

Looks like the source printing is done by https://github.com/ziglang/zig/blob/738d2be9d6b6ef3ff3559130c05159ef53336224/lib/std/debug.zig#L1160-L1177 which calls printLineFromFile, which just reads the file from the disk: https://github.com/ziglang/zig/blob/738d2be9d6b6ef3ff3559130c05159ef53336224/lib/std/debug.zig#L1188

[workingjubilee]

Thank you for finding that, @bjorn3.

That would mean it fails the ideal state suggested by @HKalbasi of being able to follow "drift" in code.

I'm not even trying to criticize the approach chosen: it makes sense to me to choose that particular midpoint in terms of binary overhead, of "go look and print it if we can find it", without embedding random lines of source.

[HKalbasi]

I think we can use the embedded source file when -Z embedded-source=yes, and try to read the file from the disk as a fallback when the source is not available in the binary. Though I would like to at least detect if the code is modified if we are using the fallback (e.g. by using a checksum) and not showing anything instead of showing the wrong codes (Zig does not check that and shows garbage/misleading codes when the source file is changed).