This thread is to continue a discussion about how we could enable panicking with accurate line info from unwrap/expect. Currently, when you unwrap a None or Err you get something along the lines of
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', ../src/libcore/option.rs:325
It would be good if this could instead print the actual location where the unwrap call occurred rather than some random location inside libcore.
So far, the suggestions for how to implement this include:
0) Replace unwrap/expect with an unwrap! macro which internally uses line!(), file!() etc.
let x = Err(23);
let y = unwrap!(x, "oh no! x == {:?}", x);
PROS:
- Doesn't require extending the language in any way. Just an addition to the standard library.
- Let's you add a format string and args to the panic message.
CONS:
- Would mean deprecating the already established conventions around the use of
unwrap/expect
The macro call appears at the front of an expression rather than in the method position.
1) Make the inlined location of an inlined function available through MIR or a macro or something, make unwrap/expect inline.
#[inline(always)]
fn unwrap(self) -> T {
...
let line: u32;
let col: u32;
unsafe {
mir!(line = Inline(Line); col = Inline(Col));
};
panic!("panicking at line == {}, col == {}", line, col);
}
PROS
- Allows existing code to work, unchanged.
CONS
- Seems kinda weird and hacky, at least to me.
2) Add a type parameter to unwrap/expect which defaults to a magic lang item which gets filled in with a different type representing the call location at every place the method is called.
impl<T> Option<T> {
fn unwrap<C: SourceContext = CallerSourceContext>(self) -> T {
match self {
Some(t) => t,
None => {
panic!("unwrap on empty Option at location: {}", C::default());
}
}
}
}
PROS
- Allows exiting code to work, unchanged.
- Exposes the API for getting call location and makes it available to non-inlined functions.
CONS
- Pollutes the type of
unwrap/expect
- Also kinda weird and hacky.
Thoughts? Ideas? Discuss!
