Port #[panic_handler] to the new attribute parsers

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -633,29 +633,7 @@ impl<S: Stage> SingleAttributeParser<S> for LangParser {
     const PATH: &[Symbol] = &[sym::lang];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
-        Allow(Target::Trait),
-        Allow(Target::Struct),
-        Allow(Target::Enum),
-        Allow(Target::Variant),
-        Allow(Target::Union),
-        Allow(Target::MacroDef),
-        Allow(Target::TyAlias),
-        Allow(Target::AssocTy),
-        Allow(Target::AssocConst),
-        Allow(Target::Fn),
-        Allow(Target::ForeignFn),
-        Allow(Target::Const),
-        Allow(Target::Mod),
-        Allow(Target::Impl { of_trait: false }),
-        Allow(Target::Method(MethodKind::Inherent)),
-        Allow(Target::Method(MethodKind::Trait { body: false })),
-        Allow(Target::Method(MethodKind::Trait { body: true })),
-        Allow(Target::Method(MethodKind::TraitImpl)),
-        Allow(Target::Crate),
-        Allow(Target::Static),
-        Allow(Target::ForeignStatic),
-    ]);
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS); // Targets are checked per lang item in `rustc_passes`
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
@@ -675,6 +653,15 @@ impl<S: Stage> SingleAttributeParser<S> for LangParser {
     }
 }
 
+pub(crate) struct PanicHandlerParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for PanicHandlerParser {
+    const PATH: &[Symbol] = &[sym::panic_handler];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS); // Targets are checked per lang item in `rustc_passes`
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::Lang(LangItem::PanicImpl);
+}
+
 pub(crate) struct RustcHasIncoherentInherentImplsParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for RustcHasIncoherentInherentImplsParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -254,6 +254,7 @@ attribute_parsers!(
         Single<WithoutArgs<NoMangleParser>>,
         Single<WithoutArgs<NoStdParser>>,
         Single<WithoutArgs<NonExhaustiveParser>>,
+        Single<WithoutArgs<PanicHandlerParser>>,
         Single<WithoutArgs<PanicRuntimeParser>>,
         Single<WithoutArgs<ParenSugarParser>>,
         Single<WithoutArgs<PassByValueParser>>,

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -8,7 +8,7 @@ use rustc_hir::attrs::{
 };
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
-use rustc_hir::{self as hir, Attribute, find_attr, lang_items};
+use rustc_hir::{self as hir, Attribute, find_attr};
 use rustc_middle::middle::codegen_fn_attrs::{
     CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry, SanitizerFnAttrs,
 };
@@ -504,7 +504,7 @@ fn handle_lang_items(
     attrs: &[Attribute],
     codegen_fn_attrs: &mut CodegenFnAttrs,
 ) {
-    let lang_item = lang_items::extract_hir(attrs);
+    let lang_item = find_attr!(attrs, AttributeKind::Lang(lang) => lang);
 
     // Weak lang items have the same semantics as "std internal" symbols in the
     // sense that they're preserved through all our LTO passes and only

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -50,7 +50,7 @@ impl AttributeKind {
             Ignore { .. } => No,
             Inline(..) => No,
             InstructionSet(..) => No,
-            Lang(..) => No,
+            Lang(..) => Yes,
             Link(..) => No,
             LinkName { .. } => Yes, // Needed for rustdoc
             LinkOrdinal { .. } => No,

compiler/rustc_hir/src/lang_items.rs

@@ -10,13 +10,12 @@
 use rustc_ast::ast;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_hir::find_attr;
 use rustc_macros::{BlobDecodable, Encodable, HashStable_Generic, PrintAttribute};
 use rustc_span::{Span, Symbol, kw, sym};
 
-use crate::attrs::{AttributeKind, PrintAttribute};
+use crate::attrs::PrintAttribute;
 use crate::def_id::DefId;
-use crate::{MethodKind, Target, hir};
+use crate::{MethodKind, Target};
 
 /// All of the lang items, defined or not.
 /// Defined lang items can come from the current crate or its dependencies.
@@ -154,18 +153,8 @@ 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_hir(attrs: &[hir::Attribute]) -> Option<LangItem> {
-    if let Some(lang) = find_attr!(attrs, AttributeKind::Lang(lang) => lang) {
-        Some(*lang)
-    } else if let Some(_) = attrs.iter().find(|attr| attr.has_name(sym::panic_handler)) {
-        Some(LangItem::PanicImpl)
-    } else {
-        None
-    }
-}
-
-/// Extracts the first `lang = "$name"` out of a list of attributes.
-/// The `#[panic_handler]` attribute is also extracted out when found.
+///
+/// This function is used for `ast::Attribute`, for `hir::Attribute` use the `find_attr!` macro with `AttributeKind::Lang`
 pub fn extract_ast(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> {
     attrs.iter().find_map(|attr| {
         Some(match attr {

compiler/rustc_passes/src/check_attr.rs

@@ -396,7 +396,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::deprecated_safe // FIXME(deprecated_safe)
                             // internal
                             | sym::prelude_import
-                            | sym::panic_handler
                             | sym::default_lib_allocator
                             | sym::rustc_diagnostic_item
                             | sym::rustc_nonnull_optimization_guaranteed
@@ -857,7 +856,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent)
             | Target::Fn => {
                 // `#[target_feature]` is not allowed in lang items.
-                if let Some(lang_item) = hir::lang_items::extract_hir(attrs)
+                if let Some(lang_item) = find_attr!(attrs, AttributeKind::Lang(lang) => lang)
                     // Calling functions with `#[target_feature]` is
                     // not unsafe on WASM, see #84988
                     && !self.tcx.sess.target.is_like_wasm

compiler/rustc_passes/src/dead.rs

@@ -22,7 +22,7 @@ use rustc_middle::ty::{self, AssocTag, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::DEAD_CODE;
 use rustc_session::lint::{self, LintExpectationId};
-use rustc_span::{Symbol, kw, sym};
+use rustc_span::{Symbol, kw};
 
 use crate::errors::{
     ChangeFields, IgnoredDerivedImpls, MultipleDeadCodes, ParentInfo, UselessAssignment,
@@ -706,12 +706,6 @@ fn has_allow_dead_code_or_lang_attr(
     tcx: TyCtxt<'_>,
     def_id: LocalDefId,
 ) -> Option<ComesFromAllowExpect> {
-    fn has_lang_attr(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-        find_attr!(tcx.get_all_attrs(def_id), AttributeKind::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 {
         let hir_id = tcx.local_def_id_to_hir_id(def_id);
         let lint_level = tcx.lint_level_at_node(lint::builtin::DEAD_CODE, hir_id).level;
@@ -732,7 +726,9 @@ fn has_allow_dead_code_or_lang_attr(
 
     if has_allow_expect_dead_code(tcx, def_id) {
         Some(ComesFromAllowExpect::Yes)
-    } else if has_used_like_attr(tcx, def_id) || has_lang_attr(tcx, def_id) {
+    } else if has_used_like_attr(tcx, def_id)
+        || find_attr!(tcx.get_all_attrs(def_id), AttributeKind::Lang(..))
+    {
         Some(ComesFromAllowExpect::No)
     } else {
         None

compiler/rustc_passes/src/weak_lang_items.rs

@@ -10,9 +10,7 @@ use rustc_middle::ty::TyCtxt;
 use rustc_session::config::CrateType;
 use rustc_target::spec::Os;
 
-use crate::errors::{
-    MissingLangItem, MissingPanicHandler, PanicUnwindWithoutStd,
-};
+use crate::errors::{MissingLangItem, MissingPanicHandler, PanicUnwindWithoutStd};
 
 /// Checks the crate for usage of weak lang items, returning a vector of all the
 /// lang items required by this crate, but not defined yet.

tests/ui/lowering/issue-96847.rs

@@ -10,7 +10,6 @@ fn main() {
     for _ in [1,2,3] {
         #![lang="foo"]
         //~^ ERROR definition of an unknown lang item: `foo`
-        //~| ERROR attribute cannot be used on expressions
         println!("foo");
     }
 }

tests/ui/lowering/issue-96847.stderr

@@ -4,14 +4,6 @@ error[E0522]: definition of an unknown lang item: `foo`
 LL |         #![lang="foo"]
    |         ^^^^^^^^^^^^^^ definition of unknown lang item `foo`
 
-error: `#[lang]` attribute cannot be used on expressions
-  --> $DIR/issue-96847.rs:11:9
-   |
-LL |         #![lang="foo"]
-   |         ^^^^^^^^^^^^^^
-   |
-   = help: `#[lang]` can be applied to associated consts, associated types, constants, crates, data types, enum variants, foreign statics, functions, inherent impl blocks, macro defs, modules, statics, traits, and type aliases
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0522`.