Optimising `assert_eq` & `assert_ne`

TL;DR: Once the compiler team fixes one optimizer regression, this seems to become a clear winner.

#[cfg(not(old))]
macro_rules! assert_eq {
    ($left:expr, $right:expr $(,)?) => {{
        if let (left_val, right_val) = (&$left, &$right) && !(*left_val == *right_val) {
            let kind = $crate::panicking::AssertKind::Eq;
            // The reborrows below are intentional. Without them, the stack slot for the
            // borrow is initialized even before the values are compared, leading to a
            // noticeable slow down.
            $crate::panicking::assert_failed(kind, &*left_val, &*right_val, $crate::option::Option::None);
        }
    }};
    ($left:expr, $right:expr, $($arg:tt)+) => {{
        if let (left_val, right_val) = (&$left, &$right) && !(*left_val == *right_val) {
            let kind = $crate::panicking::AssertKind::Eq;
            // The reborrows below are intentional. Without them, the stack slot for the
            // borrow is initialized even before the values are compared, leading to a
            // noticeable slow down.
            $crate::panicking::assert_failed(kind, &*left_val, &*right_val, $crate::option::Option::Some($crate::format_args!($($arg)+)));
        }
    }};
}

I replicated the context in my crate, so it’s now a drop in replacement. I also drop in the old macro, so it doesn’t benefit from any std-magic. I generate 1000 calls, round robin over 10 different constants, where $c is just their name.

cfg_select! {
    msg => assert_eq!(black_box($c), black_box($c), "a {} b {}", black_box($c), black_box($c)),
    _ => assert_eq!(black_box($c), black_box($c)),
}

For all 8 combinations with and without the last 3 options, I run rustc 1.101.0-nightly (76456a688 2026-10-25) 100 times from and to RAM disk. The PC is otherwise as inactive as I can get it.

export TIMEFORMAT='%9U' # user nanosecs
time /opt/rustup/toolchains/nightly-x86_64-unknown-linux-gnu/bin/rustc --emit asm --edition 2024 -O --cfg msg --cfg old

The good news is in all four scenarios old and new produce identical size asm. The mixed news is that the compiler doesn’t optimize new with message faster:

ϕ seconds w/o worst 3 w/o best 3
& worst 3
all 100 best 4th best
_msg_old 0.838827 0.845705 0.843241 0.602919 0.675757
_msg 0.803638 0.811803 0.809563 0.541333 0.596285
Δ -4.20% -4.01% -3.99% -10.21% -11.76%
_old 0.358534 0.363073 0.362178 0.213046 0.240937
_ 0.336784 0.339290 0.339542 0.255494 0.272354
Δ -6.07% -6.55% -6.25% +19.92% +13.04%
-O_msg_old 1.763747 1.772820 1.771908 1.392145 1.562478
-O_msg 1.819400 1.829742 1.828947 1.463535 1.552192
Δ +3.16% +3.21% +3.22% +5.13% -0.66%
-O_old 0.826725 0.832608 0.832530 0.632574 0.665209
-O 0.766940 0.771043 0.770704 0.627128 0.654795
Δ -7.23% -7.39% -7.43% -0.86% -1.57%

It raises some questions:

  • The reborrow comment is weird. Is this a special case, or should this rather be optimized in the compiler for all such cases? It should not be necessary to do such an optimisation oneself!

  • Should the body not be cold_path()?

  • Why the extra block? Do the statements not scope any temporaries?

Btw. we could also make the caller benefit from our reference capture. A 3rd branch could infer the message args as being the comparees: assert_eq!(black_box($c), black_box($c), "a {} b {}", _, _)

Edit: flipped the signs, as a negative Δ is good.