Using a panic! Backtrace (Unrecoverable Errors with panic! - Error Handling Rust)
The panic! macro is used to indicate that an unrecoverable error has occurred and the program should terminate. It is typically used for internal errors, such as when an assumption about the state of the program is violated.
The following example shows how to use the panic! macro:
fn main() {
let v = vec![1, 2, 3];
panic!("index out of bounds: the len is {} but the index is {}", v.len(), 99);
}
When we run this program, we get the following output:
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
The note line tells us that we can set the RUST_BACKTRACE environment variable to get a backtrace of exactly what happened to cause the error. A backtrace is a list of all the functions that have been called to get to this point.
To get a backtrace, we can set the RUST_BACKTRACE environment variable to any value except 0 and run the program again. The following output shows what we get:
thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', src/main.rs:4:5 stack backtrace: 0: rust_begin_unwind at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/std/src/panicking.rs:584:5 1: core::panicking::panic_fmt at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:142:14 2: core::panicking::panic_bounds_check at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/panicking.rs:84:5 3: <usize as core::slice::index::SliceIndex<[T]>>::index at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:242:10 4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/slice/index.rs:18:9 5: <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/alloc/src/vec/mod.rs:2591:9 6: panic::main at ./src/main.rs:4:5 7: core::ops::function::FnOnce::call_once at /rustc/e092d0b6b43f2de967af0887873151bb1c0b18d3/library/core/src/ops/function.rs:248:5 note: Some details are omitted, run with RUST_BACKTRACE=full for a verbose backtrace.
The backtrace shows us a list of all the functions that were called to get to the point where the panic occurred. The first line in the backtrace points to the line in our project that is causing the problem: line 4 of src/main.rs.
We can use the backtrace to identify the cause of the panic and fix the code accordingly. In the example above, the panic is caused because we are trying to access an element of a vector beyond the range of valid indexes. To fix the code, we can either make sure that we only access elements within the valid range, or we can handle the error gracefully if we try to access an element outside of the range.
For example, we could change the code to the following:
fn main() {
let v = vec![1, 2, 3];
if v.len() <= 99 {
v[99];
} else {
panic!("index out of bounds");
}
}
This code will only panic if we try to access the 100th element of the vector, which is beyond the range of valid indexes. Otherwise, the code will simply return.
It is also possible to recover from a panic using the catch_unwind macro. This macro allows us to catch a panic and handle it gracefully. For example, we could change the code to the following:
fn main() {
let v = vec![1, 2, 3];
let result = std::panic::catch_unwind(|| {
v[99];
});
match result {
Ok(()) => println!("Everything went well!"),
Err(err) => println!("Error: {}", err),
}
}
This code will catch any panic that occurs in the closure passed to catch_unwind. If there is a panic, the code will print an error message and continue running.
Whether or not to use panic! to handle errors depends on the specific situation. If the error is unrecoverable and the program should terminate, then using panic! is appropriate. However, if the error is recoverable and the program should continue running, then it is better to use a different error handling mechanism.
