Are unwrap()s under patterns optimized away? - performance

Question

I have some code where I often use unwrap() under patterns, where I can be sure it won't panic. Some of those pieces are in performance-critical functions, so I was wondering if it would be a good idea to get rid of these unwrap()s in favor of unchecked variants of applicable functions. However, I didn't see any difference with #[bench] tests and the ASM for both variants looks pretty similar to me (though I'm not an expert).
It appears that Rust is able to optimize such cases away; am I right or should I use unchecked functions instead of unwrap()?
MCVE:
use self::Foo::*;
use self::Error::*;
#[derive(Debug)]
enum Foo {
Bar(Box<Foo>),
Baz
}
#[derive(Debug)]
enum Error {
NotBar
}
impl Foo {
fn bar_mut_ref(&mut self) -> Result<&mut Foo, Error> {
match *self {
Bar(ref mut foo) => Ok(foo),
_ => Err(NotBar)
}
}
fn bar_mut_ref_unchecked(&mut self) -> &mut Foo {
match *self {
Bar(ref mut foo) => foo,
_ => panic!("bar_mut_ref_unchecked() called on a non-Bar!")
}
}
fn bazify(&mut self) {
match *self {
Bar(_) => { *self = Baz },
_ => ()
}
}
}
fn do_stuff_with_foo(foo: &mut Foo) {
match *foo {
Bar(_) => {
foo.bar_mut_ref().unwrap().bazify(); // is _unchecked() better here?
// underscore was used because foo is assigned to a new value here
},
_ => {}
}
}
fn main() {
let mut foo = Bar(Box::new(Bar(Box::new(Baz))));
do_stuff_with_foo(&mut foo);
println!("{:?}", foo);
}

Answer 1

A more direct comparison of the two approaches yields identical ASM, so at least for this simple example the answer appears to be: yes, such cases can be optimized away.
example::do_stuff_with_foo:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, qword ptr [rdi]
test rbx, rbx
je .LBB1_3
cmp qword ptr [rbx], 0
je .LBB1_3
mov rdi, rbx
call core::ptr::drop_in_place
mov qword ptr [rbx], 0
.LBB1_3:
add rsp, 8
pop rbx
pop rbp
ret