remove panic handler from compiler

Author: jdonszelmann

compiler/rustc_feature/src/builtin_attrs.rs

@@ -473,7 +473,6 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         template!(NameValueStr: "windows|console"), FutureWarnFollowing,
         EncodeCrossCrate::No
     ),
-    ungated!(panic_handler, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::Yes), // RFC 2070
 
     // Code generation:
     ungated!(inline, Normal, template!(Word, List: "always|never"), FutureWarnFollowing, EncodeCrossCrate::No),

compiler/rustc_hir/src/lang_items.rs

@@ -151,12 +151,10 @@ impl<CTX> HashStable<CTX> for LangItem {
 }
 
 /// Extracts the first `lang = "$name"` out of a list of attributes.
-/// The `#[panic_handler]` attribute is also extracted out when found.
 pub fn extract(attrs: &[impl AttributeExt]) -> Option<(Symbol, Span)> {
     attrs.iter().find_map(|attr| {
         Some(match attr {
             _ if attr.has_name(sym::lang) => (attr.value_str()?, attr.span()),
-            _ if attr.has_name(sym::panic_handler) => (sym::panic_impl, attr.span()),
             _ => return None,
         })
     })

compiler/rustc_hir/src/weak_lang_items.rs

@@ -24,7 +24,6 @@ macro_rules! weak_lang_items {
 }
 
 weak_lang_items! {
-    PanicImpl,          rust_begin_unwind;
     EhPersonality,      rust_eh_personality;
     EhCatchTypeinfo,    rust_eh_catch_typeinfo;
 }

compiler/rustc_hir_typeck/src/check.rs

@@ -149,72 +149,13 @@ pub(super) fn check_fn<'a, 'tcx>(
     // we have a recursive call site and do the sadly stabilized fallback to `()`.
     fcx.demand_suptype(span, ret_ty, actual_return_ty);
 
-    // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
-    if tcx.is_lang_item(fn_def_id.to_def_id(), LangItem::PanicImpl) {
-        check_panic_info_fn(tcx, fn_def_id, fn_sig);
-    }
-
     if tcx.is_lang_item(fn_def_id.to_def_id(), LangItem::Start) {
         check_lang_start_fn(tcx, fn_sig, fn_def_id);
     }
 
     fcx.coroutine_types
 }
 
-fn check_panic_info_fn(tcx: TyCtxt<'_>, fn_id: LocalDefId, fn_sig: ty::FnSig<'_>) {
-    let span = tcx.def_span(fn_id);
-
-    let DefKind::Fn = tcx.def_kind(fn_id) else {
-        tcx.dcx().span_err(span, "should be a function");
-        return;
-    };
-
-    let generic_counts = tcx.generics_of(fn_id).own_counts();
-    if generic_counts.types != 0 {
-        tcx.dcx().span_err(span, "should have no type parameters");
-    }
-    if generic_counts.consts != 0 {
-        tcx.dcx().span_err(span, "should have no const parameters");
-    }
-
-    let panic_info_did = tcx.require_lang_item(hir::LangItem::PanicInfo, Some(span));
-
-    // build type `for<'a, 'b> fn(&'a PanicInfo<'b>) -> !`
-    let panic_info_ty = tcx.type_of(panic_info_did).instantiate(
-        tcx,
-        &[ty::GenericArg::from(ty::Region::new_bound(
-            tcx,
-            ty::INNERMOST,
-            ty::BoundRegion { var: ty::BoundVar::from_u32(1), kind: ty::BoundRegionKind::Anon },
-        ))],
-    );
-    let panic_info_ref_ty = Ty::new_imm_ref(
-        tcx,
-        ty::Region::new_bound(
-            tcx,
-            ty::INNERMOST,
-            ty::BoundRegion { var: ty::BoundVar::ZERO, kind: ty::BoundRegionKind::Anon },
-        ),
-        panic_info_ty,
-    );
-
-    let bounds = tcx.mk_bound_variable_kinds(&[
-        ty::BoundVariableKind::Region(ty::BoundRegionKind::Anon),
-        ty::BoundVariableKind::Region(ty::BoundRegionKind::Anon),
-    ]);
-    let expected_sig = ty::Binder::bind_with_vars(
-        tcx.mk_fn_sig([panic_info_ref_ty], tcx.types.never, false, fn_sig.safety, ExternAbi::Rust),
-        bounds,
-    );
-
-    let _ = check_function_signature(
-        tcx,
-        ObligationCause::new(span, fn_id, ObligationCauseCode::LangFunctionType(sym::panic_impl)),
-        fn_id.into(),
-        expected_sig,
-    );
-}
-
 fn check_lang_start_fn<'tcx>(tcx: TyCtxt<'tcx>, fn_sig: ty::FnSig<'tcx>, def_id: LocalDefId) {
     // build type `fn(main: fn() -> T, argc: isize, argv: *const *const u8, sigpipe: u8)`
 

compiler/rustc_passes/src/check_attr.rs

@@ -295,7 +295,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::deprecated_safe // FIXME(deprecated_safe)
                             // internal
                             | sym::prelude_import
-                            | sym::panic_handler
                             | sym::allow_internal_unsafe
                             | sym::fundamental
                             | sym::lang

compiler/rustc_passes/src/dead.rs

@@ -691,8 +691,6 @@ fn has_allow_dead_code_or_lang_attr(
 ) -> Option<ComesFromAllowExpect> {
     fn has_lang_attr(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
         tcx.has_attr(def_id, sym::lang)
-            // Stable attribute for #[lang = "panic_impl"]
-            || tcx.has_attr(def_id, sym::panic_handler)
     }
 
     fn has_allow_expect_dead_code(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {

compiler/rustc_resolve/src/check_unused.rs

@@ -402,6 +402,7 @@ impl Resolver<'_, '_> {
                         !tcx.is_compiler_builtins(cnum)
                             && !tcx.is_panic_runtime(cnum)
                             && !tcx.has_global_allocator(cnum)
+                        // TODO: test for EII in the crate
                     }) {
                         maybe_unused_extern_crates.insert(id, import.span);
                     }

compiler/rustc_trait_selection/messages.ftl

@@ -248,10 +248,7 @@ trait_selection_oc_cant_coerce_force_inline =
 trait_selection_oc_cant_coerce_intrinsic = cannot coerce intrinsics to function pointers
 trait_selection_oc_closure_selfref = closure/coroutine type that references itself
 trait_selection_oc_const_compat = const not compatible with trait
-trait_selection_oc_fn_lang_correct_type = {$lang_item_name ->
-        [panic_impl] `#[panic_handler]`
-        *[lang_item_name] lang item `{$lang_item_name}`
-    } function has wrong type
+trait_selection_oc_fn_lang_correct_type = lang item `{$lang_item_name}` function has wrong type
 trait_selection_oc_fn_main_correct_type = `main` function has wrong type
 trait_selection_oc_generic = mismatched types
 

library/core/src/lib.rs

@@ -95,6 +95,7 @@
 //
 // Library features:
 // tidy-alphabetical-start
+#![cfg_attr(not(bootstrap), feature(eii))]
 #![feature(array_ptr_get)]
 #![feature(asm_experimental_arch)]
 #![feature(bigint_helper_methods)]
@@ -238,6 +239,9 @@ pub mod contracts;
 
 #[unstable(feature = "cfg_match", issue = "115585")]
 pub use crate::macros::cfg_match;
+#[cfg(not(bootstrap))]
+#[stable(feature = "panic_hooks", since = "1.10.0")]
+pub use crate::panic::panic_handler;
 
 #[macro_use]
 mod internal_macros;

library/core/src/panic.rs

@@ -16,6 +16,13 @@ pub use self::panic_info::PanicMessage;
 pub use self::unwind_safe::{AssertUnwindSafe, RefUnwindSafe, UnwindSafe};
 use crate::any::Any;
 
+/// Core expects some crate to provide a function annotated with `#[panic_handler]` with this
+/// signature. This annotated function will be called when a panic occurs.
+#[stable(feature = "panic_hooks", since = "1.10.0")]
+#[cfg(not(bootstrap))]
+#[eii(panic_handler)]
+pub(crate) fn panic_impl(info: &PanicInfo<'_>) -> !;
+
 #[doc(hidden)]
 #[unstable(feature = "edition_panic", issue = "none", reason = "use panic!() instead")]
 #[allow_internal_unstable(panic_internals, const_format_args)]

library/core/src/panicking.rs

@@ -56,23 +56,36 @@ pub const fn panic_fmt(fmt: fmt::Arguments<'_>) -> ! {
     if cfg!(feature = "panic_immediate_abort") {
         super::intrinsics::abort()
     }
+    #[cfg(bootstrap)]
+    {
+        // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
+        // that gets resolved to the `#[panic_handler]` function.
+        unsafe extern "Rust" {
+            #[lang = "panic_impl"]
+            fn panic_impl(pi: &PanicInfo<'_>) -> !;
+        }
 
-    // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
-    // that gets resolved to the `#[panic_handler]` function.
-    unsafe extern "Rust" {
-        #[lang = "panic_impl"]
-        fn panic_impl(pi: &PanicInfo<'_>) -> !;
-    }
-
-    let pi = PanicInfo::new(
-        &fmt,
-        Location::caller(),
-        /* can_unwind */ true,
-        /* force_no_backtrace */ false,
-    );
+        let pi = PanicInfo::new(
+            &fmt,
+            Location::caller(),
+            /* can_unwind */ true,
+            /* force_no_backtrace */ false,
+        );
 
-    // SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
-    unsafe { panic_impl(&pi) }
+        // SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
+        unsafe { panic_impl(&pi) }
+    }
+    #[cfg(not(bootstrap))]
+    {
+        let pi = PanicInfo::new(
+            &fmt,
+            Location::caller(),
+            /* can_unwind */ true,
+            /* force_no_backtrace */ false,
+        );
+
+        crate::panic::panic_impl(&pi)
+    }
 }
 
 /// Like `panic_fmt`, but for non-unwinding panics.
@@ -98,23 +111,39 @@ pub const fn panic_nounwind_fmt(fmt: fmt::Arguments<'_>, force_no_backtrace: boo
                 super::intrinsics::abort()
             }
 
-            // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
-            // that gets resolved to the `#[panic_handler]` function.
-            unsafe extern "Rust" {
-                #[lang = "panic_impl"]
-                fn panic_impl(pi: &PanicInfo<'_>) -> !;
-            }
+            #[cfg(bootstrap)]
+            {
+                // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call
+                // that gets resolved to the `#[panic_handler]` function.
+                unsafe extern "Rust" {
+                    #[lang = "panic_impl"]
+                    fn panic_impl(pi: &PanicInfo<'_>) -> !;
+                }
 
-            // PanicInfo with the `can_unwind` flag set to false forces an abort.
-            let pi = PanicInfo::new(
-                &fmt,
-                Location::caller(),
-                /* can_unwind */ false,
-                force_no_backtrace,
-            );
+                // PanicInfo with the `can_unwind` flag set to false forces an abort.
+                let pi = PanicInfo::new(
+                    &fmt,
+                    Location::caller(),
+                    /* can_unwind */ false,
+                    force_no_backtrace,
+                );
 
-            // SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
-            unsafe { panic_impl(&pi) }
+                // SAFETY: `panic_impl` is defined in safe Rust code and thus is safe to call.
+                unsafe { panic_impl(&pi) }
+            }
+
+            #[cfg(not(bootstrap))]
+            {
+                // PanicInfo with the `can_unwind` flag set to false forces an abort.
+                let pi = PanicInfo::new(
+                    &fmt,
+                    Location::caller(),
+                    /* can_unwind */ false,
+                    force_no_backtrace,
+                );
+
+                crate::panic::panic_impl(&pi)
+            }
         }
     )
 }