Enable the lint in std

Author: saethlin

library/std/src/alloc.rs

@@ -420,6 +420,7 @@ fn default_alloc_error_hook(layout: Layout) {
 #[doc(hidden)]
 #[alloc_error_handler]
 #[unstable(feature = "alloc_internals", issue = "none")]
+#[allow(missing_panic_entrypoint)]
 pub fn rust_oom(layout: Layout) -> ! {
     crate::sys::backtrace::__rust_end_short_backtrace(|| {
         let hook = HOOK.load(Ordering::Acquire);

library/std/src/lib.rs

@@ -249,6 +249,7 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(rustdoc::redundant_explicit_links)]
 #![warn(rustdoc::unescaped_backticks)]
+#![warn(missing_panic_entrypoint)]
 // Ensure that std can be linked against panic_abort despite compiled with `-C panic=unwind`
 #![deny(ffi_unwind_calls)]
 // std may use features in a platform-specific way

library/std/src/panic.rs

@@ -387,6 +387,7 @@ pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
 /// }
 /// ```
 #[stable(feature = "resume_unwind", since = "1.9.0")]
+#[allow(missing_panic_entrypoint)]
 pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
     panicking::resume_unwind(payload)
 }

library/std/src/panicking.rs

@@ -71,6 +71,7 @@ unsafe extern "Rust" {
 /// with our panic count.
 #[cfg(not(test))]
 #[rustc_std_internal_symbol]
+#[allow(missing_panic_entrypoint)]
 extern "C" fn __rust_drop_panic() -> ! {
     rtabort!("Rust panics must be rethrown");
 }
@@ -79,6 +80,7 @@ extern "C" fn __rust_drop_panic() -> ! {
 /// object which does not correspond to a Rust panic.
 #[cfg(not(test))]
 #[rustc_std_internal_symbol]
+#[allow(missing_panic_entrypoint)]
 extern "C" fn __rust_foreign_exception() -> ! {
     rtabort!("Rust cannot catch foreign exceptions");
 }
@@ -619,6 +621,7 @@ pub fn panicking() -> bool {
 /// Entry point of panics from the core crate (`panic_impl` lang item).
 #[cfg(not(any(test, doctest)))]
 #[panic_handler]
+#[allow(missing_panic_entrypoint)]
 pub fn panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
     struct FormatStringPayload<'a> {
         inner: &'a core::panic::PanicMessage<'a>,
@@ -711,17 +714,14 @@ pub fn panic_handler(info: &core::panic::PanicInfo<'_>) -> ! {
 #[unstable(feature = "libstd_sys_internals", reason = "used by the panic! macro", issue = "none")]
 #[cfg_attr(not(any(test, doctest)), lang = "begin_panic")]
 // lang item for CTFE panic support
-// never inline unless panic=immediate-abort to avoid code
-// bloat at the call sites as much as possible
-#[cfg_attr(not(panic = "immediate-abort"), inline(never), cold, optimize(size))]
-#[cfg_attr(panic = "immediate-abort", inline)]
+// never inline to avoid code bloat at the call sites as much as possible
+#[cold]
+#[inline(never)]
+#[optimize(size)]
 #[track_caller]
 #[rustc_do_not_const_check] // hooked by const-eval
+#[rustc_panic_entrypoint]
 pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
-    if cfg!(panic = "immediate-abort") {
-        intrinsics::abort()
-    }
-
     struct Payload<A> {
         inner: Option<A>,
     }
@@ -784,6 +784,7 @@ fn payload_as_str(payload: &dyn Any) -> &str {
 /// panics, panic hooks, and finally dispatching to the panic runtime to either
 /// abort or unwind.
 #[optimize(size)]
+#[allow(missing_panic_entrypoint)]
 fn panic_with_hook(
     payload: &mut dyn PanicPayload,
     location: &Location<'_>,
@@ -853,6 +854,7 @@ fn panic_with_hook(
 /// This is the entry point for `resume_unwind`.
 /// It just forwards the payload to the panic runtime.
 #[cfg_attr(panic = "immediate-abort", inline)]
+#[allow(missing_panic_entrypoint)]
 pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
     panic_count::increase(false);
 
@@ -881,14 +883,8 @@ pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
 /// on which to slap yer breakpoints.
 #[inline(never)]
 #[cfg_attr(not(test), rustc_std_internal_symbol)]
-#[cfg(not(panic = "immediate-abort"))]
+#[rustc_panic_entrypoint]
 fn rust_panic(msg: &mut dyn PanicPayload) -> ! {
     let code = unsafe { __rust_start_panic(msg) };
     rtabort!("failed to initiate panic, error {code}")
 }
-
-#[cfg_attr(not(test), rustc_std_internal_symbol)]
-#[cfg(panic = "immediate-abort")]
-fn rust_panic(_: &mut dyn PanicPayload) -> ! {
-    crate::intrinsics::abort();
-}

library/std/src/process.rs

@@ -2160,6 +2160,7 @@ impl ExitCode {
     /// }
     /// ```
     #[unstable(feature = "exitcode_exit_method", issue = "97100")]
+    #[allow(missing_panic_entrypoint)]
     pub fn exit_process(self) -> ! {
         exit(self.to_i32())
     }
@@ -2462,6 +2463,7 @@ impl Child {
 /// [C-exit]: https://en.cppreference.com/w/c/program/exit
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "process_exit")]
+#[allow(missing_panic_entrypoint)]
 pub fn exit(code: i32) -> ! {
     crate::rt::cleanup();
     crate::sys::os::exit(code)
@@ -2529,6 +2531,7 @@ pub fn exit(code: i32) -> ! {
 #[cold]
 #[cfg_attr(not(test), rustc_diagnostic_item = "process_abort")]
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+#[allow(missing_panic_entrypoint)]
 pub fn abort() -> ! {
     crate::sys::abort_internal();
 }

library/std/src/sync/lazy_lock.rs

@@ -406,6 +406,7 @@ impl<T: fmt::Debug, F> fmt::Debug for LazyLock<T, F> {
 
 #[cold]
 #[inline(never)]
+#[rustc_panic_entrypoint]
 fn panic_poisoned() -> ! {
     panic!("LazyLock instance has previously been poisoned")
 }

library/std/src/sys/pal/unix/mod.rs

@@ -358,6 +358,7 @@ pub fn cvt_nz(error: libc::c_int) -> crate::io::Result<()> {
 // stdlib doesn't use libc stdio buffering.  In a typical Rust program, which
 // does not use C stdio, even a buggy libc::abort() is, in fact, safe.
 #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+#[allow(missing_panic_entrypoint)]
 pub fn abort_internal() -> ! {
     unsafe { libc::abort() }
 }

library/std/src/sys/pal/unix/os.rs

@@ -663,6 +663,7 @@ pub fn home_dir() -> Option<PathBuf> {
     }
 }
 
+#[allow(missing_panic_entrypoint)]
 pub fn exit(code: i32) -> ! {
     crate::sys::exit_guard::unique_thread_exit();
     unsafe { libc::exit(code as c_int) }

library/std/src/thread/id.rs

@@ -34,6 +34,7 @@ impl ThreadId {
     // Generate a new unique thread ID.
     pub(crate) fn new() -> ThreadId {
         #[cold]
+        #[rustc_panic_entrypoint]
         fn exhausted() -> ! {
             panic!("failed to generate unique thread ID: bitspace exhausted")
         }

library/std/src/thread/local.rs

@@ -428,9 +428,9 @@ impl fmt::Display for AccessError {
 impl Error for AccessError {}
 
 // This ensures the panicking code is outlined from `with` for `LocalKey`.
-#[cfg_attr(not(panic = "immediate-abort"), inline(never))]
 #[track_caller]
 #[cold]
+#[rustc_panic_entrypoint]
 fn panic_access_error(err: AccessError) -> ! {
     panic!("cannot access a Thread Local Storage value during or after destruction: {err:?}")
 }