Remove redundant attributes

Author: saethlin

compiler/rustc_lint/src/builtin.rs

@@ -25,11 +25,11 @@ use rustc_attr_parsing::AttributeParser;
 use rustc_errors::{Applicability, LintDiagnostic};
 use rustc_feature::GateIssue;
 use rustc_hir as hir;
-use rustc_hir::attrs::{AttributeKind, DocAttribute, InlineAttr};
+use rustc_hir::attrs::{AttributeKind, DocAttribute};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_hir::intravisit::FnKind as HirFnKind;
-use rustc_hir::{AttrPath, Body, FnDecl, ImplItemImplKind, PatKind, PredicateOrigin, find_attr};
+use rustc_hir::{Body, FnDecl, ImplItemImplKind, PatKind, PredicateOrigin, find_attr};
 use rustc_middle::bug;
 use rustc_middle::lint::LevelAndSource;
 use rustc_middle::ty::layout::LayoutOf;
@@ -3187,100 +3187,3 @@ impl EarlyLintPass for SpecialModuleName {
         }
     }
 }
-
-declare_lint! {
-    /// The `missing_panic_entrypoint` lint detects forgotten use of #[rustc_panic_entrypoint]
-    ///
-    /// ### Example
-    ///
-    /// ```rust,compile_fail
-    /// # #![cfg(not(bootstrap))]
-    /// #[deny(missing_panic_entrypoint)]
-    /// pub fn panic_wrapper() -> ! {
-    ///     panic!("ouch!")
-    /// }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// This lint is intended to ensure that panic=immediate-abort can function as designed,
-    /// because it uses #[rustc_panic_entrypoint] to locate functions that should be outlined
-    /// for other panic modes, and be deleted entirely when immediate-abort is enabled.
-    pub MISSING_PANIC_ENTRYPOINT,
-    Allow,
-    "detects missing #[rustc_panic_entrypoint]",
-}
-
-#[derive(Default)]
-pub struct MissingPanicEntrypoint;
-
-impl_lint_pass!(MissingPanicEntrypoint => [MISSING_PANIC_ENTRYPOINT]);
-
-fn has_panic_entrypoint(attrs: &[hir::Attribute]) -> bool {
-    attrs.iter().any(|attr| {
-        if let hir::Attribute::Unparsed(box hir::AttrItem {
-            path: AttrPath { segments, .. }, ..
-        }) = attr
-        {
-            if segments[0].name == sym::rustc_panic_entrypoint {
-                return true;
-            }
-        }
-        false
-    })
-}
-
-fn has_inline_encouragement(attrs: &[hir::Attribute]) -> bool {
-    attrs.iter().any(|attr| {
-        matches!(
-            attr,
-            hir::Attribute::Parsed(hir::attrs::AttributeKind::Inline(
-                InlineAttr::Hint | InlineAttr::Always | InlineAttr::Force { .. },
-                _
-            ))
-        )
-    })
-}
-
-fn has_rustc_intrinsic(attrs: &[hir::Attribute]) -> bool {
-    attrs.iter().any(|attr| {
-        if let hir::Attribute::Unparsed(box hir::AttrItem {
-            path: AttrPath { segments, .. }, ..
-        }) = attr
-        {
-            if segments[0].name == sym::rustc_intrinsic {
-                return true;
-            }
-        }
-        false
-    })
-}
-
-impl<'tcx> LateLintPass<'tcx> for MissingPanicEntrypoint {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: HirFnKind<'tcx>,
-        fn_decl: &'tcx FnDecl<'tcx>,
-        _: &'tcx Body<'tcx>,
-        span: Span,
-        def_id: LocalDefId,
-    ) {
-        if matches!(fn_decl.output, hir::FnRetTy::Return(hir::Ty { kind: hir::TyKind::Never, .. }))
-        {
-            let attrs = cx.tcx.hir_attrs(cx.tcx.local_def_id_to_hir_id(def_id));
-            if has_rustc_intrinsic(attrs) {
-                return;
-            }
-            if !has_inline_encouragement(attrs) && !has_panic_entrypoint(attrs) {
-                cx.emit_span_lint(
-                    MISSING_PANIC_ENTRYPOINT,
-                    span,
-                    crate::lints::MissingPanicEntrypoint,
-                );
-            }
-        }
-    }
-}

compiler/rustc_lint/src/internal.rs

@@ -1,12 +1,14 @@
 //! Some lints that are only useful in the compiler or crates that use compiler internals, such as
 //! Clippy.
 
-use rustc_hir::attrs::AttributeKind;
+use rustc_hir::attrs::{AttributeKind, InlineAttr};
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, ExprKind, HirId, find_attr};
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{AttrPath, Body, Expr, ExprKind, FnDecl, HirId, find_attr};
 use rustc_middle::ty::{self, GenericArgsRef, PredicatePolarity, Ty};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_span::def_id::LocalDefId;
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::{Span, sym};
 use tracing::debug;
@@ -784,3 +786,84 @@ impl EarlyLintPass for ImplicitSysrootCrateImport {
         }
     }
 }
+
+declare_tool_lint! {
+    /// The `missing_panic_entrypoint` lint detects forgotten use of #[rustc_panic_entrypoint].
+    ///
+    /// This lint is intended to ensure that panic=immediate-abort can function as designed,
+    /// because it uses #[rustc_panic_entrypoint] to locate functions that should be outlined
+    /// for other panic modes, and be deleted entirely when immediate-abort is enabled.
+    pub rustc::MISSING_PANIC_ENTRYPOINT,
+    Allow,
+    "detects missing #[rustc_panic_entrypoint]",
+    report_in_external_macro: false
+}
+
+declare_lint_pass!(MissingPanicEntrypoint => [MISSING_PANIC_ENTRYPOINT]);
+
+fn has_panic_entrypoint(attrs: &[hir::Attribute]) -> bool {
+    attrs.iter().any(|attr| {
+        if let hir::Attribute::Unparsed(box hir::AttrItem {
+            path: AttrPath { segments, .. }, ..
+        }) = attr
+        {
+            if segments[0].name == sym::rustc_panic_entrypoint {
+                return true;
+            }
+        }
+        false
+    })
+}
+
+fn has_inline_encouragement(attrs: &[hir::Attribute]) -> bool {
+    attrs.iter().any(|attr| {
+        matches!(
+            attr,
+            hir::Attribute::Parsed(hir::attrs::AttributeKind::Inline(
+                InlineAttr::Hint | InlineAttr::Always | InlineAttr::Force { .. },
+                _
+            ))
+        )
+    })
+}
+
+fn has_rustc_intrinsic(attrs: &[hir::Attribute]) -> bool {
+    attrs.iter().any(|attr| {
+        if let hir::Attribute::Unparsed(box hir::AttrItem {
+            path: AttrPath { segments, .. }, ..
+        }) = attr
+        {
+            if segments[0].name == sym::rustc_intrinsic {
+                return true;
+            }
+        }
+        false
+    })
+}
+
+impl<'tcx> LateLintPass<'tcx> for MissingPanicEntrypoint {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        fn_decl: &'tcx FnDecl<'tcx>,
+        _: &'tcx Body<'tcx>,
+        span: Span,
+        def_id: LocalDefId,
+    ) {
+        if matches!(fn_decl.output, hir::FnRetTy::Return(hir::Ty { kind: hir::TyKind::Never, .. }))
+        {
+            let attrs = cx.tcx.hir_attrs(cx.tcx.local_def_id_to_hir_id(def_id));
+            if has_rustc_intrinsic(attrs) {
+                return;
+            }
+            if !has_inline_encouragement(attrs) && !has_panic_entrypoint(attrs) {
+                cx.emit_span_lint(
+                    MISSING_PANIC_ENTRYPOINT,
+                    span,
+                    crate::lints::MissingPanicEntrypoint,
+                );
+            }
+        }
+    }
+}

library/alloc/src/alloc.rs

@@ -394,8 +394,6 @@ unsafe extern "Rust" {
 #[stable(feature = "global_alloc", since = "1.28.0")]
 #[rustc_const_unstable(feature = "const_alloc_error", issue = "92523")]
 #[cfg(not(no_global_oom_handling))]
-#[cold]
-#[optimize(size)]
 #[rustc_panic_entrypoint]
 pub const fn handle_alloc_error(layout: Layout) -> ! {
     #[inline]

library/alloc/src/raw_vec/mod.rs

@@ -23,8 +23,6 @@ mod tests;
 // ensure that the code generation related to these panics is minimal as there's
 // only one location which panics rather than a bunch throughout the module.
 #[cfg(not(no_global_oom_handling))]
-#[cold]
-#[inline(never)]
 #[rustc_panic_entrypoint]
 fn capacity_overflow() -> ! {
     panic!("capacity overflow");
@@ -839,8 +837,6 @@ impl<A: Allocator> RawVecInner<A> {
 
 // Central function for reserve error handling.
 #[cfg(not(no_global_oom_handling))]
-#[cold]
-#[optimize(size)]
 #[rustc_panic_entrypoint]
 fn handle_error(e: TryReserveError) -> ! {
     match e.kind() {

library/alloc/src/vec/mod.rs

@@ -2027,9 +2027,6 @@ impl<T, A: Allocator> Vec<T, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn swap_remove(&mut self, index: usize) -> T {
-        #[cold]
-        #[inline(never)]
-        #[optimize(size)]
         #[track_caller]
         #[rustc_panic_entrypoint]
         fn assert_failed(index: usize, len: usize) -> ! {
@@ -2110,10 +2107,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[track_caller]
     #[must_use = "if you don't need a reference to the value, use `Vec::insert` instead"]
     pub fn insert_mut(&mut self, index: usize, element: T) -> &mut T {
-        #[cold]
-        #[inline(never)]
         #[track_caller]
-        #[optimize(size)]
         #[rustc_panic_entrypoint]
         fn assert_failed(index: usize, len: usize) -> ! {
             panic!("insertion index (is {index}) should be <= len (is {len})");
@@ -2175,10 +2169,7 @@ impl<T, A: Allocator> Vec<T, A> {
     #[track_caller]
     #[rustc_confusables("delete", "take")]
     pub fn remove(&mut self, index: usize) -> T {
-        #[cold]
-        #[inline(never)]
         #[track_caller]
-        #[optimize(size)]
         #[rustc_panic_entrypoint]
         fn assert_failed(index: usize, len: usize) -> ! {
             panic!("removal index (is {index}) should be < len (is {len})");
@@ -2971,10 +2962,7 @@ impl<T, A: Allocator> Vec<T, A> {
     where
         A: Clone,
     {
-        #[cold]
-        #[inline(never)]
         #[track_caller]
-        #[optimize(size)]
         #[rustc_panic_entrypoint]
         fn assert_failed(at: usize, len: usize) -> ! {
             panic!("`at` split index (is {at}) should be <= len (is {len})");

library/core/src/cell.rs

@@ -885,8 +885,6 @@ impl Display for BorrowMutError {
 
 // This ensures the panicking code is outlined from `borrow_mut` for `RefCell`.
 #[track_caller]
-#[cold]
-#[inline(never)]
 #[rustc_panic_entrypoint]
 const fn panic_already_borrowed(err: BorrowMutError) -> ! {
     const_panic!(
@@ -898,8 +896,6 @@ const fn panic_already_borrowed(err: BorrowMutError) -> ! {
 
 // This ensures the panicking code is outlined from `borrow` for `RefCell`.
 #[track_caller]
-#[cold]
-#[inline(never)]
 #[rustc_panic_entrypoint]
 const fn panic_already_mutably_borrowed(err: BorrowError) -> ! {
     const_panic!(

library/core/src/cell/lazy.rs

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

library/core/src/num/int_log10.rs

@@ -164,7 +164,6 @@ define_signed_ilog10! {
 
 /// Instantiate this panic logic once, rather than for all the ilog methods
 /// on every single primitive type.
-#[cold]
 #[track_caller]
 #[rustc_panic_entrypoint]
 pub(super) const fn panic_for_nonpositive_argument() -> ! {

library/core/src/num/int_sqrt.rs

@@ -309,7 +309,6 @@ unsigned_fn!(u128, u64, u128_stages);
 
 /// Instantiate this panic logic once, rather than for all the isqrt methods
 /// on every single primitive type.
-#[cold]
 #[track_caller]
 #[rustc_panic_entrypoint]
 pub(super) const fn panic_for_negative_argument() -> ! {

library/core/src/num/mod.rs

@@ -1388,8 +1388,6 @@ pub const fn can_not_overflow<T>(radix: u32, is_signed_ty: bool, digits: &[u8])
     radix <= 16 && digits.len() <= size_of::<T>() * 2 - is_signed_ty as usize
 }
 
-#[cold]
-#[inline(never)]
 #[track_caller]
 #[rustc_panic_entrypoint]
 const fn from_ascii_radix_panic(radix: u32) -> ! {