1#![allow(dead_code, missing_docs)]
25#![unstable(
26    feature = "panic_internals",
27    reason = "internal details of the implementation of the `panic!` and related macros",
28    issue = "none"
29)]
30
31use crate::fmt;
32use crate::intrinsics::const_eval_select;
33use crate::panic::{Location, PanicInfo};
34
35#[cfg(feature = "panic_immediate_abort")]
36const _: () = assert!(cfg!(panic = "abort"), "panic_immediate_abort requires -C panic=abort");
37
38#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
50#[cfg_attr(feature = "panic_immediate_abort", inline)]
51#[track_caller]
52#[lang = "panic_fmt"] #[rustc_do_not_const_check] #[rustc_const_stable_indirect] pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
56    if cfg!(feature = "panic_immediate_abort") {
57        super::intrinsics::abort()
58    }
59
60    unsafe extern "Rust" {
63        #[lang = "panic_impl"]
64        fn panic_impl(pi: &PanicInfo<'_>) -> !;
65    }
66
67    let pi = PanicInfo::new(
68        &fmt,
69        Location::caller(),
70        true,
71        false,
72    );
73
74    unsafe { panic_impl(&pi) }
76}
77
78#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
82#[cfg_attr(feature = "panic_immediate_abort", inline)]
83#[track_caller]
84#[rustc_nounwind]
88#[rustc_const_stable_indirect] #[rustc_allow_const_fn_unstable(const_eval_select)]
90pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: bool) -> ! {
91    const_eval_select!(
92        @capture { fmt: fmt::Arguments<'_>, force_no_backtrace: bool } -> !:
93        if const #[track_caller] {
94            panic_fmt(fmt)
96        } else #[track_caller] {
97            if cfg!(feature = "panic_immediate_abort") {
98                super::intrinsics::abort()
99            }
100
101            unsafe extern "Rust" {
104                #[lang = "panic_impl"]
105                fn panic_impl(pi: &PanicInfo<'_>) -> !;
106            }
107
108            let pi = PanicInfo::new(
110                &fmt,
111                Location::caller(),
112                false,
113                force_no_backtrace,
114            );
115
116            unsafe { panic_impl(&pi) }
118        }
119    )
120}
121
122#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
129#[cfg_attr(feature = "panic_immediate_abort", inline)]
130#[track_caller]
131#[rustc_const_stable_indirect] #[lang = "panic"] pub const fn panic(expr: &'static str) -> ! {
134    panic_fmt(fmt::Arguments::new_const(&[expr]));
146}
147
148macro_rules! panic_const {
157    ($($lang:ident = $message:expr,)+) => {
158        $(
159            #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
164            #[cfg_attr(feature = "panic_immediate_abort", inline)]
165            #[track_caller]
166            #[rustc_const_stable_indirect] #[lang = stringify!($lang)]
168            pub const fn $lang() -> ! {
169                panic_fmt(fmt::Arguments::new_const(&[$message]));
176            }
177        )+
178    }
179}
180
181pub mod panic_const {
186    use super::*;
187    panic_const! {
188        panic_const_add_overflow = "attempt to add with overflow",
189        panic_const_sub_overflow = "attempt to subtract with overflow",
190        panic_const_mul_overflow = "attempt to multiply with overflow",
191        panic_const_div_overflow = "attempt to divide with overflow",
192        panic_const_rem_overflow = "attempt to calculate the remainder with overflow",
193        panic_const_neg_overflow = "attempt to negate with overflow",
194        panic_const_shr_overflow = "attempt to shift right with overflow",
195        panic_const_shl_overflow = "attempt to shift left with overflow",
196        panic_const_div_by_zero = "attempt to divide by zero",
197        panic_const_rem_by_zero = "attempt to calculate the remainder with a divisor of zero",
198        panic_const_coroutine_resumed = "coroutine resumed after completion",
199        panic_const_async_fn_resumed = "`async fn` resumed after completion",
200        panic_const_async_gen_fn_resumed = "`async gen fn` resumed after completion",
201        panic_const_gen_fn_none = "`gen fn` should just keep returning `None` after completion",
202        panic_const_coroutine_resumed_panic = "coroutine resumed after panicking",
203        panic_const_async_fn_resumed_panic = "`async fn` resumed after panicking",
204        panic_const_async_gen_fn_resumed_panic = "`async gen fn` resumed after panicking",
205        panic_const_gen_fn_none_panic = "`gen fn` should just keep returning `None` after panicking",
206    }
207    #[cfg(not(bootstrap))]
210    panic_const! {
211        panic_const_coroutine_resumed_drop = "coroutine resumed after async drop",
212        panic_const_async_fn_resumed_drop = "`async fn` resumed after async drop",
213        panic_const_async_gen_fn_resumed_drop = "`async gen fn` resumed after async drop",
214        panic_const_gen_fn_none_drop = "`gen fn` resumed after async drop",
215    }
216}
217
218#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
221#[cfg_attr(feature = "panic_immediate_abort", inline)]
222#[lang = "panic_nounwind"] #[rustc_nounwind]
224#[rustc_const_stable_indirect] pub const fn panic_nounwind(expr: &'static str) -> ! {
226    panic_nounwind_fmt(fmt::Arguments::new_const(&[expr]), false);
227}
228
229#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
231#[cfg_attr(feature = "panic_immediate_abort", inline)]
232#[rustc_nounwind]
233pub fn panic_nounwind_nobacktrace(expr: &'static str) -> ! {
234    panic_nounwind_fmt(fmt::Arguments::new_const(&[expr]), true);
235}
236
237#[track_caller]
238#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
239#[cfg_attr(feature = "panic_immediate_abort", inline)]
240#[rustc_const_stable_indirect] pub const fn panic_explicit() -> ! {
242    panic_display(&"explicit panic");
243}
244
245#[inline]
246#[track_caller]
247#[rustc_diagnostic_item = "unreachable_display"] pub fn unreachable_display<T: fmt::Display>(x: &T) -> ! {
249    panic_fmt(format_args!("internal error: entered unreachable code: {}", *x));
250}
251
252#[inline]
255#[track_caller]
256#[rustc_diagnostic_item = "panic_str_2015"]
257#[rustc_const_stable_indirect] pub const fn panic_str_2015(expr: &str) -> ! {
259    panic_display(&expr);
260}
261
262#[inline]
263#[track_caller]
264#[rustc_do_not_const_check] #[rustc_const_panic_str]
267#[rustc_const_stable_indirect] pub const fn panic_display<T: fmt::Display>(x: &T) -> ! {
269    panic_fmt(format_args!("{}", *x));
270}
271
272#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
273#[cfg_attr(feature = "panic_immediate_abort", inline)]
274#[track_caller]
275#[lang = "panic_bounds_check"] fn panic_bounds_check(index: usize, len: usize) -> ! {
277    if cfg!(feature = "panic_immediate_abort") {
278        super::intrinsics::abort()
279    }
280
281    panic!("index out of bounds: the len is {len} but the index is {index}")
282}
283
284#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
285#[cfg_attr(feature = "panic_immediate_abort", inline)]
286#[track_caller]
287#[lang = "panic_misaligned_pointer_dereference"] #[rustc_nounwind] fn panic_misaligned_pointer_dereference(required: usize, found: usize) -> ! {
290    if cfg!(feature = "panic_immediate_abort") {
291        super::intrinsics::abort()
292    }
293
294    panic_nounwind_fmt(
295        format_args!(
296            "misaligned pointer dereference: address must be a multiple of {required:#x} but is {found:#x}"
297        ),
298        false,
299    )
300}
301
302#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
303#[cfg_attr(feature = "panic_immediate_abort", inline)]
304#[track_caller]
305#[lang = "panic_null_pointer_dereference"] #[rustc_nounwind] fn panic_null_pointer_dereference() -> ! {
308    if cfg!(feature = "panic_immediate_abort") {
309        super::intrinsics::abort()
310    }
311
312    panic_nounwind_fmt(
313        format_args!("null pointer dereference occurred"),
314        false,
315    )
316}
317
318#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
326#[cfg_attr(feature = "panic_immediate_abort", inline)]
327#[lang = "panic_cannot_unwind"] #[rustc_nounwind]
329fn panic_cannot_unwind() -> ! {
330    panic_nounwind("panic in a function that cannot unwind")
332}
333
334#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
342#[cfg_attr(feature = "panic_immediate_abort", inline)]
343#[lang = "panic_in_cleanup"] #[rustc_nounwind]
345fn panic_in_cleanup() -> ! {
346    panic_nounwind_nobacktrace("panic in a destructor during cleanup")
348}
349
350#[lang = "const_panic_fmt"] #[rustc_const_stable_indirect] pub const fn const_panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
354    if let Some(msg) = fmt.as_str() {
355        panic_display(&msg);
357    } else {
358        unsafe { crate::hint::unreachable_unchecked() };
362    }
363}
364
365#[derive(Debug)]
366#[doc(hidden)]
367pub enum AssertKind {
368    Eq,
369    Ne,
370    Match,
371}
372
373#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
375#[cfg_attr(feature = "panic_immediate_abort", inline)]
376#[track_caller]
377#[doc(hidden)]
378pub fn assert_failed<T, U>(
379    kind: AssertKind,
380    left: &T,
381    right: &U,
382    args: Option<fmt::Arguments<'_>>,
383) -> !
384where
385    T: fmt::Debug + ?Sized,
386    U: fmt::Debug + ?Sized,
387{
388    assert_failed_inner(kind, &left, &right, args)
389}
390
391#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
393#[cfg_attr(feature = "panic_immediate_abort", inline)]
394#[track_caller]
395#[doc(hidden)]
396pub fn assert_matches_failed<T: fmt::Debug + ?Sized>(
397    left: &T,
398    right: &str,
399    args: Option<fmt::Arguments<'_>>,
400) -> ! {
401    struct Pattern<'a>(&'a str);
403    impl fmt::Debug for Pattern<'_> {
404        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
405            f.write_str(self.0)
406        }
407    }
408    assert_failed_inner(AssertKind::Match, &left, &Pattern(right), args);
409}
410
411#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold, optimize(size))]
413#[cfg_attr(feature = "panic_immediate_abort", inline)]
414#[track_caller]
415fn assert_failed_inner(
416    kind: AssertKind,
417    left: &dyn fmt::Debug,
418    right: &dyn fmt::Debug,
419    args: Option<fmt::Arguments<'_>>,
420) -> ! {
421    let op = match kind {
422        AssertKind::Eq => "==",
423        AssertKind::Ne => "!=",
424        AssertKind::Match => "matches",
425    };
426
427    match args {
428        Some(args) => panic!(
429            r#"assertion `left {op} right` failed: {args}
430  left: {left:?}
431 right: {right:?}"#
432        ),
433        None => panic!(
434            r#"assertion `left {op} right` failed
435  left: {left:?}
436 right: {right:?}"#
437        ),
438    }
439}