Compiler Explorer

Source code

#[unsafe(no_mangle)]
pub fn sample_function_custom_message(x: i32, y: i32) -> i32 {
    fast_assert!(
        x > y,
        "x ({}) should be greater than y ({})", x, y
    );
    return x - y
}

/// A reimplementation of assert! that uses a closure to defer all
/// panic-related work to the cold path.
#[macro_export]
macro_rules! fast_assert {
    // Rule 1: Handles calls with only a condition, like my_assert!(x == y).
    // It also accepts an optional trailing comma, like my_assert!(x == y,).
    ($cond:expr $(,)?) => {
        if !$cond {
            // If the condition is false, panic with a default message.
            // The stringify! macro converts the expression `$cond` into a string literal,
            // so the error message includes the exact code that failed.
            $crate::cold::assert_failed_default(stringify!($cond));
        }
    };
    // Rule 2: Handles calls with a condition and a custom message,
    // like my_assert!(x == y, "x should be equal to y, but was {}", x).
    ($cond:expr, $($arg:tt)+) => {
        if !$cond {
            // We pass a closure to the cold function.
            // No code inside this closure will be generated in the hot path.
            $crate::cold::assert_failed_custom(|| {
                panic!($($arg)+);
            });
        }
    };
}

/// Private implementation detail.
/// `pub` is required to make macros work from other crates, so stick #[doc(hidden)] on it.
#[doc(hidden)]
pub mod cold {
    /// This function is marked as `#[cold]` to hint to the compiler that it's
    /// rarely executed. The compiler uses this to optimize the call site,
    /// keeping the "hot path" (where the assertion succeeds) as lean as possible.
    ///
    /// Counter-intuitively, #[inline] reduces the amount of extra instructions from 5 to 2.
    /// It removes the assembly lines related to tracking the caller location,
    /// which makes sense: this lets each call site have its own dedicated function
    /// that already knows where it was called from, as opposed to all call sites
    /// dispatching to a single function and having to tell it where they came from.
    #[cold]
    #[inline]
    #[track_caller]
    pub fn assert_failed_default(condition: &'static str) -> ! {
        panic!("assertion failed: {}", condition);
    }

/// A cold function for assertions with custom messages.
    ///
    /// This function is generic over a closure `F`.
    /// `F: FnOnce()` means it accepts any closure that can be called once
    /// and takes no arguments.
    ///
    /// The panic logic is provided by the caller via this closure.
    ///
    /// This doesn't need #[inline] because the function is generic
    /// and will be separately instantiated for each call site.
    #[cold]
    #[track_caller]
    pub fn assert_failed_custom<F>(msg_fn: F)
    where
        F: FnOnce(),
    {
        // We simply call the closure, which contains the panic!.
        msg_fn();
    }
}