compiler/rustc_passes/src/check_attr.rs

   1 //! This module implements some validity checks for attributes.
   2 //! In particular it verifies that `#[inline]` and `#[repr]` attributes are
   3 //! attached to items that actually support them and if there are
   4 //! conflicts between multiple such attributes attached to the same
   5 //! item.
   6
   7 use crate::errors::{
   8     self, AttrApplication, DebugVisualizerUnreadable, InvalidAttrAtCrateLevel, ObjectLifetimeErr,
   9     OnlyHasEffectOn, TransparentIncompatible, UnrecognizedReprHint,
  10 };
  11 use rustc_ast::{ast, AttrStyle, Attribute, LitKind, MetaItemKind, MetaItemLit, NestedMetaItem};
  12 use rustc_data_structures::fx::FxHashMap;
  13 use rustc_errors::{fluent, Applicability, MultiSpan};
  14 use rustc_expand::base::resolve_path;
  15 use rustc_feature::{AttributeDuplicates, AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
  16 use rustc_hir as hir;
  17 use rustc_hir::def_id::LocalDefId;
  18 use rustc_hir::intravisit::{self, Visitor};
  19 use rustc_hir::{
  20     self, FnSig, ForeignItem, HirId, Item, ItemKind, TraitItem, CRATE_HIR_ID, CRATE_OWNER_ID,
  21 };
  22 use rustc_hir::{MethodKind, Target};
  23 use rustc_middle::hir::nested_filter;
  24 use rustc_middle::middle::resolve_lifetime::ObjectLifetimeDefault;
  25 use rustc_middle::ty::query::Providers;
  26 use rustc_middle::ty::TyCtxt;
  27 use rustc_session::lint::builtin::{
  28     CONFLICTING_REPR_HINTS, INVALID_DOC_ATTRIBUTES, UNUSED_ATTRIBUTES,
  29 };
  30 use rustc_session::parse::feature_err;
  31 use rustc_span::symbol::{kw, sym, Symbol};
  32 use rustc_span::{Span, DUMMY_SP};
  33 use rustc_target::spec::abi::Abi;
  34 use std::collections::hash_map::Entry;
  35
  36 pub(crate) fn target_from_impl_item<'tcx>(
  37     tcx: TyCtxt<'tcx>,
  38     impl_item: &hir::ImplItem<'_>,
  39 ) -> Target {
  40     match impl_item.kind {
  41         hir::ImplItemKind::Const(..) => Target::AssocConst,
  42         hir::ImplItemKind::Fn(..) => {
  43             let parent_def_id = tcx.hir().get_parent_item(impl_item.hir_id()).def_id;
  44             let containing_item = tcx.hir().expect_item(parent_def_id);
  45             let containing_impl_is_for_trait = match &containing_item.kind {
  46                 hir::ItemKind::Impl(impl_) => impl_.of_trait.is_some(),
  47                 _ => bug!("parent of an ImplItem must be an Impl"),
  48             };
  49             if containing_impl_is_for_trait {
  50                 Target::Method(MethodKind::Trait { body: true })
  51             } else {
  52                 Target::Method(MethodKind::Inherent)
  53             }
  54         }
  55         hir::ImplItemKind::Type(..) => Target::AssocTy,
  56     }
  57 }
  58
  59 #[derive(Clone, Copy)]
  60 enum ItemLike<'tcx> {
  61     Item(&'tcx Item<'tcx>),
  62     ForeignItem,
  63 }
  64
  65 struct CheckAttrVisitor<'tcx> {
  66     tcx: TyCtxt<'tcx>,
  67 }
  68
  69 impl CheckAttrVisitor<'_> {
  70     /// Checks any attribute.
  71     fn check_attributes(
  72         &self,
  73         hir_id: HirId,
  74         span: Span,
  75         target: Target,
  76         item: Option<ItemLike<'_>>,
  77     ) {
  78         let mut doc_aliases = FxHashMap::default();
  79         let mut is_valid = true;
  80         let mut specified_inline = None;
  81         let mut seen = FxHashMap::default();
  82         let attrs = self.tcx.hir().attrs(hir_id);
  83         for attr in attrs {
  84             let attr_is_valid = match attr.name_or_empty() {
  85                 sym::inline => self.check_inline(hir_id, attr, span, target),
  86                 sym::no_coverage => self.check_no_coverage(hir_id, attr, span, target),
  87                 sym::non_exhaustive => self.check_non_exhaustive(hir_id, attr, span, target),
  88                 sym::marker => self.check_marker(hir_id, attr, span, target),
  89                 sym::rustc_must_implement_one_of => {
  90                     self.check_rustc_must_implement_one_of(attr, span, target)
  91                 }
  92                 sym::target_feature => self.check_target_feature(hir_id, attr, span, target),
  93                 sym::thread_local => self.check_thread_local(attr, span, target),
  94                 sym::track_caller => {
  95                     self.check_track_caller(hir_id, attr.span, attrs, span, target)
  96                 }
  97                 sym::doc => self.check_doc_attrs(
  98                     attr,
  99                     hir_id,
 100                     target,
 101                     &mut specified_inline,
 102                     &mut doc_aliases,
 103                 ),
 104                 sym::no_link => self.check_no_link(hir_id, &attr, span, target),
 105                 sym::export_name => self.check_export_name(hir_id, &attr, span, target),
 106                 sym::rustc_layout_scalar_valid_range_start
 107                 | sym::rustc_layout_scalar_valid_range_end => {
 108                     self.check_rustc_layout_scalar_valid_range(&attr, span, target)
 109                 }
 110                 sym::allow_internal_unstable => {
 111                     self.check_allow_internal_unstable(hir_id, &attr, span, target, &attrs)
 112                 }
 113                 sym::debugger_visualizer => self.check_debugger_visualizer(&attr, target),
 114                 sym::rustc_allow_const_fn_unstable => {
 115                     self.check_rustc_allow_const_fn_unstable(hir_id, &attr, span, target)
 116                 }
 117                 sym::rustc_std_internal_symbol => {
 118                     self.check_rustc_std_internal_symbol(&attr, span, target)
 119                 }
 120                 sym::naked => self.check_naked(hir_id, attr, span, target),
 121                 sym::rustc_legacy_const_generics => {
 122                     self.check_rustc_legacy_const_generics(hir_id, &attr, span, target, item)
 123                 }
 124                 sym::rustc_lint_query_instability => {
 125                     self.check_rustc_lint_query_instability(hir_id, &attr, span, target)
 126                 }
 127                 sym::rustc_lint_diagnostics => {
 128                     self.check_rustc_lint_diagnostics(hir_id, &attr, span, target)
 129                 }
 130                 sym::rustc_lint_opt_ty => self.check_rustc_lint_opt_ty(&attr, span, target),
 131                 sym::rustc_lint_opt_deny_field_access => {
 132                     self.check_rustc_lint_opt_deny_field_access(&attr, span, target)
 133                 }
 134                 sym::rustc_clean
 135                 | sym::rustc_dirty
 136                 | sym::rustc_if_this_changed
 137                 | sym::rustc_then_this_would_need => self.check_rustc_dirty_clean(&attr),
 138                 sym::cmse_nonsecure_entry => {
 139                     self.check_cmse_nonsecure_entry(hir_id, attr, span, target)
 140                 }
 141                 sym::collapse_debuginfo => self.check_collapse_debuginfo(attr, span, target),
 142                 sym::const_trait => self.check_const_trait(attr, span, target),
 143                 sym::must_not_suspend => self.check_must_not_suspend(&attr, span, target),
 144                 sym::must_use => self.check_must_use(hir_id, &attr, target),
 145                 sym::rustc_pass_by_value => self.check_pass_by_value(&attr, span, target),
 146                 sym::rustc_allow_incoherent_impl => {
 147                     self.check_allow_incoherent_impl(&attr, span, target)
 148                 }
 149                 sym::rustc_has_incoherent_inherent_impls => {
 150                     self.check_has_incoherent_inherent_impls(&attr, span, target)
 151                 }
 152                 sym::rustc_const_unstable
 153                 | sym::rustc_const_stable
 154                 | sym::unstable
 155                 | sym::stable
 156                 | sym::rustc_allowed_through_unstable_modules
 157                 | sym::rustc_promotable => self.check_stability_promotable(&attr, span, target),
 158                 sym::link_ordinal => self.check_link_ordinal(&attr, span, target),
 159                 _ => true,
 160             };
 161             is_valid &= attr_is_valid;
 162
 163             // lint-only checks
 164             match attr.name_or_empty() {
 165                 sym::cold => self.check_cold(hir_id, attr, span, target),
 166                 sym::link => self.check_link(hir_id, attr, span, target),
 167                 sym::link_name => self.check_link_name(hir_id, attr, span, target),
 168                 sym::link_section => self.check_link_section(hir_id, attr, span, target),
 169                 sym::no_mangle => self.check_no_mangle(hir_id, attr, span, target),
 170                 sym::deprecated => self.check_deprecated(hir_id, attr, span, target),
 171                 sym::macro_use | sym::macro_escape => self.check_macro_use(hir_id, attr, target),
 172                 sym::path => self.check_generic_attr(hir_id, attr, target, Target::Mod),
 173                 sym::plugin_registrar => self.check_plugin_registrar(hir_id, attr, target),
 174                 sym::macro_export => self.check_macro_export(hir_id, attr, target),
 175                 sym::ignore | sym::should_panic | sym::proc_macro_derive => {
 176                     self.check_generic_attr(hir_id, attr, target, Target::Fn)
 177                 }
 178                 sym::automatically_derived => {
 179                     self.check_generic_attr(hir_id, attr, target, Target::Impl)
 180                 }
 181                 sym::no_implicit_prelude => {
 182                     self.check_generic_attr(hir_id, attr, target, Target::Mod)
 183                 }
 184                 sym::rustc_object_lifetime_default => self.check_object_lifetime_default(hir_id),
 185                 _ => {}
 186             }
 187
 188             let builtin = attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name));
 189
 190             if hir_id != CRATE_HIR_ID {
 191                 if let Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) =
 192                     attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name))
 193                 {
 194                     match attr.style {
 195                         ast::AttrStyle::Outer => self.tcx.emit_spanned_lint(
 196                             UNUSED_ATTRIBUTES,
 197                             hir_id,
 198                             attr.span,
 199                             errors::OuterCrateLevelAttr,
 200                         ),
 201                         ast::AttrStyle::Inner => self.tcx.emit_spanned_lint(
 202                             UNUSED_ATTRIBUTES,
 203                             hir_id,
 204                             attr.span,
 205                             errors::InnerCrateLevelAttr,
 206                         ),
 207                     }
 208                 }
 209             }
 210
 211             if let Some(BuiltinAttribute { duplicates, .. }) = builtin {
 212                 check_duplicates(self.tcx, attr, hir_id, *duplicates, &mut seen);
 213             }
 214
 215             self.check_unused_attribute(hir_id, attr)
 216         }
 217
 218         if !is_valid {
 219             return;
 220         }
 221
 222         self.check_repr(attrs, span, target, item, hir_id);
 223         self.check_used(attrs, target);
 224     }
 225
 226     fn inline_attr_str_error_with_macro_def(&self, hir_id: HirId, attr: &Attribute, sym: &str) {
 227         self.tcx.emit_spanned_lint(
 228             UNUSED_ATTRIBUTES,
 229             hir_id,
 230             attr.span,
 231             errors::IgnoredAttrWithMacro { sym },
 232         );
 233     }
 234
 235     fn inline_attr_str_error_without_macro_def(&self, hir_id: HirId, attr: &Attribute, sym: &str) {
 236         self.tcx.emit_spanned_lint(
 237             UNUSED_ATTRIBUTES,
 238             hir_id,
 239             attr.span,
 240             errors::IgnoredAttr { sym },
 241         );
 242     }
 243
 244     /// Checks if an `#[inline]` is applied to a function or a closure. Returns `true` if valid.
 245     fn check_inline(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
 246         match target {
 247             Target::Fn
 248             | Target::Closure
 249             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
 250             Target::Method(MethodKind::Trait { body: false }) | Target::ForeignFn => {
 251                 self.tcx.emit_spanned_lint(
 252                     UNUSED_ATTRIBUTES,
 253                     hir_id,
 254                     attr.span,
 255                     errors::IgnoredInlineAttrFnProto,
 256                 );
 257                 true
 258             }
 259             // FIXME(#65833): We permit associated consts to have an `#[inline]` attribute with
 260             // just a lint, because we previously erroneously allowed it and some crates used it
 261             // accidentally, to be compatible with crates depending on them, we can't throw an
 262             // error here.
 263             Target::AssocConst => {
 264                 self.tcx.emit_spanned_lint(
 265                     UNUSED_ATTRIBUTES,
 266                     hir_id,
 267                     attr.span,
 268                     errors::IgnoredInlineAttrConstants,
 269                 );
 270                 true
 271             }
 272             // FIXME(#80564): Same for fields, arms, and macro defs
 273             Target::Field | Target::Arm | Target::MacroDef => {
 274                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "inline");
 275                 true
 276             }
 277             _ => {
 278                 self.tcx.sess.emit_err(errors::InlineNotFnOrClosure {
 279                     attr_span: attr.span,
 280                     defn_span: span,
 281                 });
 282                 false
 283             }
 284         }
 285     }
 286
 287     /// Checks if a `#[no_coverage]` is applied directly to a function
 288     fn check_no_coverage(
 289         &self,
 290         hir_id: HirId,
 291         attr: &Attribute,
 292         span: Span,
 293         target: Target,
 294     ) -> bool {
 295         match target {
 296             // no_coverage on function is fine
 297             Target::Fn
 298             | Target::Closure
 299             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
 300
 301             // function prototypes can't be covered
 302             Target::Method(MethodKind::Trait { body: false }) | Target::ForeignFn => {
 303                 self.tcx.emit_spanned_lint(
 304                     UNUSED_ATTRIBUTES,
 305                     hir_id,
 306                     attr.span,
 307                     errors::IgnoredNoCoverageFnProto,
 308                 );
 309                 true
 310             }
 311
 312             Target::Mod | Target::ForeignMod | Target::Impl | Target::Trait => {
 313                 self.tcx.emit_spanned_lint(
 314                     UNUSED_ATTRIBUTES,
 315                     hir_id,
 316                     attr.span,
 317                     errors::IgnoredNoCoveragePropagate,
 318                 );
 319                 true
 320             }
 321
 322             Target::Expression | Target::Statement | Target::Arm => {
 323                 self.tcx.emit_spanned_lint(
 324                     UNUSED_ATTRIBUTES,
 325                     hir_id,
 326                     attr.span,
 327                     errors::IgnoredNoCoverageFnDefn,
 328                 );
 329                 true
 330             }
 331
 332             _ => {
 333                 self.tcx.sess.emit_err(errors::IgnoredNoCoverageNotCoverable {
 334                     attr_span: attr.span,
 335                     defn_span: span,
 336                 });
 337                 false
 338             }
 339         }
 340     }
 341
 342     fn check_generic_attr(
 343         &self,
 344         hir_id: HirId,
 345         attr: &Attribute,
 346         target: Target,
 347         allowed_target: Target,
 348     ) {
 349         if target != allowed_target {
 350             self.tcx.emit_spanned_lint(
 351                 UNUSED_ATTRIBUTES,
 352                 hir_id,
 353                 attr.span,
 354                 OnlyHasEffectOn {
 355                     attr_name: attr.name_or_empty(),
 356                     target_name: allowed_target.name().replace(' ', "_"),
 357                 },
 358             );
 359         }
 360     }
 361
 362     /// Checks if `#[naked]` is applied to a function definition.
 363     fn check_naked(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
 364         match target {
 365             Target::Fn
 366             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
 367             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
 368             // `#[allow_internal_unstable]` attribute with just a lint, because we previously
 369             // erroneously allowed it and some crates used it accidentally, to be compatible
 370             // with crates depending on them, we can't throw an error here.
 371             Target::Field | Target::Arm | Target::MacroDef => {
 372                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "naked");
 373                 true
 374             }
 375             _ => {
 376                 self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
 377                     attr_span: attr.span,
 378                     defn_span: span,
 379                     on_crate: hir_id == CRATE_HIR_ID,
 380                 });
 381                 false
 382             }
 383         }
 384     }
 385
 386     /// Checks if `#[cmse_nonsecure_entry]` is applied to a function definition.
 387     fn check_cmse_nonsecure_entry(
 388         &self,
 389         hir_id: HirId,
 390         attr: &Attribute,
 391         span: Span,
 392         target: Target,
 393     ) -> bool {
 394         match target {
 395             Target::Fn
 396             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
 397             _ => {
 398                 self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
 399                     attr_span: attr.span,
 400                     defn_span: span,
 401                     on_crate: hir_id == CRATE_HIR_ID,
 402                 });
 403                 false
 404             }
 405         }
 406     }
 407
 408     /// Debugging aid for `object_lifetime_default` query.
 409     fn check_object_lifetime_default(&self, hir_id: HirId) {
 410         let tcx = self.tcx;
 411         if let Some(generics) = tcx.hir().get_generics(tcx.hir().local_def_id(hir_id)) {
 412             for p in generics.params {
 413                 let hir::GenericParamKind::Type { .. } = p.kind else { continue };
 414                 let default = tcx.object_lifetime_default(p.def_id);
 415                 let repr = match default {
 416                     ObjectLifetimeDefault::Empty => "BaseDefault".to_owned(),
 417                     ObjectLifetimeDefault::Static => "'static".to_owned(),
 418                     ObjectLifetimeDefault::Param(def_id) => tcx.item_name(def_id).to_string(),
 419                     ObjectLifetimeDefault::Ambiguous => "Ambiguous".to_owned(),
 420                 };
 421                 tcx.sess.emit_err(ObjectLifetimeErr { span: p.span, repr });
 422             }
 423         }
 424     }
 425
 426     /// Checks if `#[collapse_debuginfo]` is applied to a macro.
 427     fn check_collapse_debuginfo(&self, attr: &Attribute, span: Span, target: Target) -> bool {
 428         match target {
 429             Target::MacroDef => true,
 430             _ => {
 431                 self.tcx
 432                     .sess
 433                     .emit_err(errors::CollapseDebuginfo { attr_span: attr.span, defn_span: span });
 434                 false
 435             }
 436         }
 437     }
 438
 439     /// Checks if a `#[track_caller]` is applied to a non-naked function. Returns `true` if valid.
 440     fn check_track_caller(
 441         &self,
 442         hir_id: HirId,
 443         attr_span: Span,
 444         attrs: &[Attribute],
 445         span: Span,
 446         target: Target,
 447     ) -> bool {
 448         match target {
 449             _ if attrs.iter().any(|attr| attr.has_name(sym::naked)) => {
 450                 self.tcx.sess.emit_err(errors::NakedTrackedCaller { attr_span });
 451                 false
 452             }
 453             Target::Fn | Target::Method(..) | Target::ForeignFn | Target::Closure => true,
 454             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
 455             // `#[track_caller]` attribute with just a lint, because we previously
 456             // erroneously allowed it and some crates used it accidentally, to be compatible
 457             // with crates depending on them, we can't throw an error here.
 458             Target::Field | Target::Arm | Target::MacroDef => {
 459                 for attr in attrs {
 460                     self.inline_attr_str_error_with_macro_def(hir_id, attr, "track_caller");
 461                 }
 462                 true
 463             }
 464             _ => {
 465                 self.tcx.sess.emit_err(errors::TrackedCallerWrongLocation {
 466                     attr_span,
 467                     defn_span: span,
 468                     on_crate: hir_id == CRATE_HIR_ID,
 469                 });
 470                 false
 471             }
 472         }
 473     }
 474
 475     /// Checks if the `#[non_exhaustive]` attribute on an `item` is valid. Returns `true` if valid.
 476     fn check_non_exhaustive(
 477         &self,
 478         hir_id: HirId,
 479         attr: &Attribute,
 480         span: Span,
 481         target: Target,
 482     ) -> bool {
 483         match target {
 484             Target::Struct | Target::Enum | Target::Variant => true,
 485             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
 486             // `#[non_exhaustive]` attribute with just a lint, because we previously
 487             // erroneously allowed it and some crates used it accidentally, to be compatible
 488             // with crates depending on them, we can't throw an error here.
 489             Target::Field | Target::Arm | Target::MacroDef => {
 490                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "non_exhaustive");
 491                 true
 492             }
 493             _ => {
 494                 self.tcx.sess.emit_err(errors::NonExhaustiveWrongLocation {
 495                     attr_span: attr.span,
 496                     defn_span: span,
 497                 });
 498                 false
 499             }
 500         }
 501     }
 502
 503     /// Checks if the `#[marker]` attribute on an `item` is valid. Returns `true` if valid.
 504     fn check_marker(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
 505         match target {
 506             Target::Trait => true,
 507             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
 508             // `#[marker]` attribute with just a lint, because we previously
 509             // erroneously allowed it and some crates used it accidentally, to be compatible
 510             // with crates depending on them, we can't throw an error here.
 511             Target::Field | Target::Arm | Target::MacroDef => {
 512                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "marker");
 513                 true
 514             }
 515             _ => {
 516                 self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToTrait {
 517                     attr_span: attr.span,
 518                     defn_span: span,
 519                 });
 520                 false
 521             }
 522         }
 523     }
 524
 525     /// Checks if the `#[rustc_must_implement_one_of]` attribute on a `target` is valid. Returns `true` if valid.
 526     fn check_rustc_must_implement_one_of(
 527         &self,
 528         attr: &Attribute,
 529         span: Span,
 530         target: Target,
 531     ) -> bool {
 532         match target {
 533             Target::Trait => true,
 534             _ => {
 535                 self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToTrait {
 536                     attr_span: attr.span,
 537                     defn_span: span,
 538                 });
 539                 false
 540             }
 541         }
 542     }
 543
 544     /// Checks if the `#[target_feature]` attribute on `item` is valid. Returns `true` if valid.
 545     fn check_target_feature(
 546         &self,
 547         hir_id: HirId,
 548         attr: &Attribute,
 549         span: Span,
 550         target: Target,
 551     ) -> bool {
 552         match target {
 553             Target::Fn
 554             | Target::Method(MethodKind::Trait { body: true } | MethodKind::Inherent) => true,
 555             // FIXME: #[target_feature] was previously erroneously allowed on statements and some
 556             // crates used this, so only emit a warning.
 557             Target::Statement => {
 558                 self.tcx.emit_spanned_lint(
 559                     UNUSED_ATTRIBUTES,
 560                     hir_id,
 561                     attr.span,
 562                     errors::TargetFeatureOnStatement,
 563                 );
 564                 true
 565             }
 566             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
 567             // `#[target_feature]` attribute with just a lint, because we previously
 568             // erroneously allowed it and some crates used it accidentally, to be compatible
 569             // with crates depending on them, we can't throw an error here.
 570             Target::Field | Target::Arm | Target::MacroDef => {
 571                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "target_feature");
 572                 true
 573             }
 574             _ => {
 575                 self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
 576                     attr_span: attr.span,
 577                     defn_span: span,
 578                     on_crate: hir_id == CRATE_HIR_ID,
 579                 });
 580                 false
 581             }
 582         }
 583     }
 584
 585     /// Checks if the `#[thread_local]` attribute on `item` is valid. Returns `true` if valid.
 586     fn check_thread_local(&self, attr: &Attribute, span: Span, target: Target) -> bool {
 587         match target {
 588             Target::ForeignStatic | Target::Static => true,
 589             _ => {
 590                 self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToStatic {
 591                     attr_span: attr.span,
 592                     defn_span: span,
 593                 });
 594                 false
 595             }
 596         }
 597     }
 598
 599     fn doc_attr_str_error(&self, meta: &NestedMetaItem, attr_name: &str) {
 600         self.tcx.sess.emit_err(errors::DocExpectStr { attr_span: meta.span(), attr_name });
 601     }
 602
 603     fn check_doc_alias_value(
 604         &self,
 605         meta: &NestedMetaItem,
 606         doc_alias: Symbol,
 607         hir_id: HirId,
 608         target: Target,
 609         is_list: bool,
 610         aliases: &mut FxHashMap<String, Span>,
 611     ) -> bool {
 612         let tcx = self.tcx;
 613         let span = meta.name_value_literal_span().unwrap_or_else(|| meta.span());
 614         let attr_str =
 615             &format!("`#[doc(alias{})]`", if is_list { "(\"...\")" } else { " = \"...\"" });
 616         if doc_alias == kw::Empty {
 617             tcx.sess.emit_err(errors::DocAliasEmpty { span, attr_str });
 618             return false;
 619         }
 620
 621         let doc_alias_str = doc_alias.as_str();
 622         if let Some(c) = doc_alias_str
 623             .chars()
 624             .find(|&c| c == '"' || c == '\'' || (c.is_whitespace() && c != ' '))
 625         {
 626             tcx.sess.emit_err(errors::DocAliasBadChar { span, attr_str, char_: c });
 627             return false;
 628         }
 629         if doc_alias_str.starts_with(' ') || doc_alias_str.ends_with(' ') {
 630             tcx.sess.emit_err(errors::DocAliasStartEnd { span, attr_str });
 631             return false;
 632         }
 633
 634         let span = meta.span();
 635         if let Some(location) = match target {
 636             Target::AssocTy => {
 637                 let parent_def_id = self.tcx.hir().get_parent_item(hir_id).def_id;
 638                 let containing_item = self.tcx.hir().expect_item(parent_def_id);
 639                 if Target::from_item(containing_item) == Target::Impl {
 640                     Some("type alias in implementation block")
 641                 } else {
 642                     None
 643                 }
 644             }
 645             Target::AssocConst => {
 646                 let parent_def_id = self.tcx.hir().get_parent_item(hir_id).def_id;
 647                 let containing_item = self.tcx.hir().expect_item(parent_def_id);
 648                 // We can't link to trait impl's consts.
 649                 let err = "associated constant in trait implementation block";
 650                 match containing_item.kind {
 651                     ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) => Some(err),
 652                     _ => None,
 653                 }
 654             }
 655             // we check the validity of params elsewhere
 656             Target::Param => return false,
 657             Target::Expression
 658             | Target::Statement
 659             | Target::Arm
 660             | Target::ForeignMod
 661             | Target::Closure
 662             | Target::Impl => Some(target.name()),
 663             Target::ExternCrate
 664             | Target::Use
 665             | Target::Static
 666             | Target::Const
 667             | Target::Fn
 668             | Target::Mod
 669             | Target::GlobalAsm
 670             | Target::TyAlias
 671             | Target::OpaqueTy
 672             | Target::ImplTraitPlaceholder
 673             | Target::Enum
 674             | Target::Variant
 675             | Target::Struct
 676             | Target::Field
 677             | Target::Union
 678             | Target::Trait
 679             | Target::TraitAlias
 680             | Target::Method(..)
 681             | Target::ForeignFn
 682             | Target::ForeignStatic
 683             | Target::ForeignTy
 684             | Target::GenericParam(..)
 685             | Target::MacroDef
 686             | Target::PatField
 687             | Target::ExprField => None,
 688         } {
 689             tcx.sess.emit_err(errors::DocAliasBadLocation { span, attr_str, location });
 690             return false;
 691         }
 692         let item_name = self.tcx.hir().name(hir_id);
 693         if item_name == doc_alias {
 694             tcx.sess.emit_err(errors::DocAliasNotAnAlias { span, attr_str });
 695             return false;
 696         }
 697         if let Err(entry) = aliases.try_insert(doc_alias_str.to_owned(), span) {
 698             self.tcx.emit_spanned_lint(
 699                 UNUSED_ATTRIBUTES,
 700                 hir_id,
 701                 span,
 702                 errors::DocAliasDuplicated { first_defn: *entry.entry.get() },
 703             );
 704         }
 705         true
 706     }
 707
 708     fn check_doc_alias(
 709         &self,
 710         meta: &NestedMetaItem,
 711         hir_id: HirId,
 712         target: Target,
 713         aliases: &mut FxHashMap<String, Span>,
 714     ) -> bool {
 715         if let Some(values) = meta.meta_item_list() {
 716             let mut errors = 0;
 717             for v in values {
 718                 match v.literal() {
 719                     Some(l) => match l.kind {
 720                         LitKind::Str(s, _) => {
 721                             if !self.check_doc_alias_value(v, s, hir_id, target, true, aliases) {
 722                                 errors += 1;
 723                             }
 724                         }
 725                         _ => {
 726                             self.tcx
 727                                 .sess
 728                                 .emit_err(errors::DocAliasNotStringLiteral { span: v.span() });
 729                             errors += 1;
 730                         }
 731                     },
 732                     None => {
 733                         self.tcx.sess.emit_err(errors::DocAliasNotStringLiteral { span: v.span() });
 734                         errors += 1;
 735                     }
 736                 }
 737             }
 738             errors == 0
 739         } else if let Some(doc_alias) = meta.value_str() {
 740             self.check_doc_alias_value(meta, doc_alias, hir_id, target, false, aliases)
 741         } else {
 742             self.tcx.sess.emit_err(errors::DocAliasMalformed { span: meta.span() });
 743             false
 744         }
 745     }
 746
 747     fn check_doc_keyword(&self, meta: &NestedMetaItem, hir_id: HirId) -> bool {
 748         let doc_keyword = meta.value_str().unwrap_or(kw::Empty);
 749         if doc_keyword == kw::Empty {
 750             self.doc_attr_str_error(meta, "keyword");
 751             return false;
 752         }
 753         match self.tcx.hir().find(hir_id).and_then(|node| match node {
 754             hir::Node::Item(item) => Some(&item.kind),
 755             _ => None,
 756         }) {
 757             Some(ItemKind::Mod(ref module)) => {
 758                 if !module.item_ids.is_empty() {
 759                     self.tcx.sess.emit_err(errors::DocKeywordEmptyMod { span: meta.span() });
 760                     return false;
 761                 }
 762             }
 763             _ => {
 764                 self.tcx.sess.emit_err(errors::DocKeywordNotMod { span: meta.span() });
 765                 return false;
 766             }
 767         }
 768         if !rustc_lexer::is_ident(doc_keyword.as_str()) {
 769             self.tcx.sess.emit_err(errors::DocKeywordInvalidIdent {
 770                 span: meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
 771                 doc_keyword,
 772             });
 773             return false;
 774         }
 775         true
 776     }
 777
 778     fn check_doc_fake_variadic(&self, meta: &NestedMetaItem, hir_id: HirId) -> bool {
 779         match self.tcx.hir().find(hir_id).and_then(|node| match node {
 780             hir::Node::Item(item) => Some(&item.kind),
 781             _ => None,
 782         }) {
 783             Some(ItemKind::Impl(ref i)) => {
 784                 let is_valid = matches!(&i.self_ty.kind, hir::TyKind::Tup([_]))
 785                     || if let hir::TyKind::BareFn(bare_fn_ty) = &i.self_ty.kind {
 786                         bare_fn_ty.decl.inputs.len() == 1
 787                     } else {
 788                         false
 789                     };
 790                 if !is_valid {
 791                     self.tcx.sess.emit_err(errors::DocFakeVariadicNotValid { span: meta.span() });
 792                     return false;
 793                 }
 794             }
 795             _ => {
 796                 self.tcx.sess.emit_err(errors::DocKeywordOnlyImpl { span: meta.span() });
 797                 return false;
 798             }
 799         }
 800         true
 801     }
 802
 803     /// Checks `#[doc(inline)]`/`#[doc(no_inline)]` attributes. Returns `true` if valid.
 804     ///
 805     /// A doc inlining attribute is invalid if it is applied to a non-`use` item, or
 806     /// if there are conflicting attributes for one item.
 807     ///
 808     /// `specified_inline` is used to keep track of whether we have
 809     /// already seen an inlining attribute for this item.
 810     /// If so, `specified_inline` holds the value and the span of
 811     /// the first `inline`/`no_inline` attribute.
 812     fn check_doc_inline(
 813         &self,
 814         attr: &Attribute,
 815         meta: &NestedMetaItem,
 816         hir_id: HirId,
 817         target: Target,
 818         specified_inline: &mut Option<(bool, Span)>,
 819     ) -> bool {
 820         if target == Target::Use || target == Target::ExternCrate {
 821             let do_inline = meta.name_or_empty() == sym::inline;
 822             if let Some((prev_inline, prev_span)) = *specified_inline {
 823                 if do_inline != prev_inline {
 824                     let mut spans = MultiSpan::from_spans(vec![prev_span, meta.span()]);
 825                     spans.push_span_label(prev_span, fluent::passes_doc_inline_conflict_first);
 826                     spans.push_span_label(meta.span(), fluent::passes_doc_inline_conflict_second);
 827                     self.tcx.sess.emit_err(errors::DocKeywordConflict { spans });
 828                     return false;
 829                 }
 830                 true
 831             } else {
 832                 *specified_inline = Some((do_inline, meta.span()));
 833                 true
 834             }
 835         } else {
 836             self.tcx.emit_spanned_lint(
 837                 INVALID_DOC_ATTRIBUTES,
 838                 hir_id,
 839                 meta.span(),
 840                 errors::DocInlineOnlyUse {
 841                     attr_span: meta.span(),
 842                     item_span: (attr.style == AttrStyle::Outer)
 843                         .then(|| self.tcx.hir().span(hir_id)),
 844                 },
 845             );
 846             false
 847         }
 848     }
 849
 850     /// Checks that an attribute is *not* used at the crate level. Returns `true` if valid.
 851     fn check_attr_not_crate_level(
 852         &self,
 853         meta: &NestedMetaItem,
 854         hir_id: HirId,
 855         attr_name: &str,
 856     ) -> bool {
 857         if CRATE_HIR_ID == hir_id {
 858             self.tcx.sess.emit_err(errors::DocAttrNotCrateLevel { span: meta.span(), attr_name });
 859             return false;
 860         }
 861         true
 862     }
 863
 864     /// Checks that an attribute is used at the crate level. Returns `true` if valid.
 865     fn check_attr_crate_level(
 866         &self,
 867         attr: &Attribute,
 868         meta: &NestedMetaItem,
 869         hir_id: HirId,
 870     ) -> bool {
 871         if hir_id != CRATE_HIR_ID {
 872             self.tcx.struct_span_lint_hir(
 873                 INVALID_DOC_ATTRIBUTES,
 874                 hir_id,
 875                 meta.span(),
 876                 fluent::passes_attr_crate_level,
 877                 |err| {
 878                     if attr.style == AttrStyle::Outer
 879                         && self.tcx.hir().get_parent_item(hir_id) == CRATE_OWNER_ID
 880                     {
 881                         if let Ok(mut src) = self.tcx.sess.source_map().span_to_snippet(attr.span) {
 882                             src.insert(1, '!');
 883                             err.span_suggestion_verbose(
 884                                 attr.span,
 885                                 fluent::suggestion,
 886                                 src,
 887                                 Applicability::MaybeIncorrect,
 888                             );
 889                         } else {
 890                             err.span_help(attr.span, fluent::help);
 891                         }
 892                     }
 893                     err.note(fluent::note);
 894                     err
 895                 },
 896             );
 897             return false;
 898         }
 899         true
 900     }
 901
 902     /// Checks that `doc(test(...))` attribute contains only valid attributes. Returns `true` if
 903     /// valid.
 904     fn check_test_attr(&self, meta: &NestedMetaItem, hir_id: HirId) -> bool {
 905         let mut is_valid = true;
 906         if let Some(metas) = meta.meta_item_list() {
 907             for i_meta in metas {
 908                 match i_meta.name_or_empty() {
 909                     sym::attr | sym::no_crate_inject => {}
 910                     _ => {
 911                         self.tcx.emit_spanned_lint(
 912                             INVALID_DOC_ATTRIBUTES,
 913                             hir_id,
 914                             i_meta.span(),
 915                             errors::DocTestUnknown {
 916                                 path: rustc_ast_pretty::pprust::path_to_string(
 917                                     &i_meta.meta_item().unwrap().path,
 918                                 ),
 919                             },
 920                         );
 921                         is_valid = false;
 922                     }
 923                 }
 924             }
 925         } else {
 926             self.tcx.emit_spanned_lint(
 927                 INVALID_DOC_ATTRIBUTES,
 928                 hir_id,
 929                 meta.span(),
 930                 errors::DocTestTakesList,
 931             );
 932             is_valid = false;
 933         }
 934         is_valid
 935     }
 936
 937     /// Check that the `#![doc(cfg_hide(...))]` attribute only contains a list of attributes.
 938     /// Returns `true` if valid.
 939     fn check_doc_cfg_hide(&self, meta: &NestedMetaItem, hir_id: HirId) -> bool {
 940         if meta.meta_item_list().is_some() {
 941             true
 942         } else {
 943             self.tcx.emit_spanned_lint(
 944                 INVALID_DOC_ATTRIBUTES,
 945                 hir_id,
 946                 meta.span(),
 947                 errors::DocCfgHideTakesList,
 948             );
 949             false
 950         }
 951     }
 952
 953     /// Runs various checks on `#[doc]` attributes. Returns `true` if valid.
 954     ///
 955     /// `specified_inline` should be initialized to `None` and kept for the scope
 956     /// of one item. Read the documentation of [`check_doc_inline`] for more information.
 957     ///
 958     /// [`check_doc_inline`]: Self::check_doc_inline
 959     fn check_doc_attrs(
 960         &self,
 961         attr: &Attribute,
 962         hir_id: HirId,
 963         target: Target,
 964         specified_inline: &mut Option<(bool, Span)>,
 965         aliases: &mut FxHashMap<String, Span>,
 966     ) -> bool {
 967         let mut is_valid = true;
 968
 969         if let Some(mi) = attr.meta() && let Some(list) = mi.meta_item_list() {
 970             for meta in list {
 971                 if let Some(i_meta) = meta.meta_item() {
 972                     match i_meta.name_or_empty() {
 973                         sym::alias
 974                             if !self.check_attr_not_crate_level(meta, hir_id, "alias")
 975                                 || !self.check_doc_alias(meta, hir_id, target, aliases) =>
 976                         {
 977                             is_valid = false
 978                         }
 979
 980                         sym::keyword
 981                             if !self.check_attr_not_crate_level(meta, hir_id, "keyword")
 982                                 || !self.check_doc_keyword(meta, hir_id) =>
 983                         {
 984                             is_valid = false
 985                         }
 986
 987                         sym::fake_variadic
 988                             if !self.check_attr_not_crate_level(meta, hir_id, "fake_variadic")
 989                                 || !self.check_doc_fake_variadic(meta, hir_id) =>
 990                         {
 991                             is_valid = false
 992                         }
 993
 994                         sym::html_favicon_url
 995                         | sym::html_logo_url
 996                         | sym::html_playground_url
 997                         | sym::issue_tracker_base_url
 998                         | sym::html_root_url
 999                         | sym::html_no_source
1000                         | sym::test
1001                             if !self.check_attr_crate_level(attr, meta, hir_id) =>
1002                         {
1003                             is_valid = false;
1004                         }
1005
1006                         sym::cfg_hide
1007                             if !self.check_attr_crate_level(attr, meta, hir_id)
1008                                 || !self.check_doc_cfg_hide(meta, hir_id) =>
1009                         {
1010                             is_valid = false;
1011                         }
1012
1013                         sym::inline | sym::no_inline
1014                             if !self.check_doc_inline(
1015                                 attr,
1016                                 meta,
1017                                 hir_id,
1018                                 target,
1019                                 specified_inline,
1020                             ) =>
1021                         {
1022                             is_valid = false;
1023                         }
1024
1025                         // no_default_passes: deprecated
1026                         // passes: deprecated
1027                         // plugins: removed, but rustdoc warns about it itself
1028                         sym::alias
1029                         | sym::cfg
1030                         | sym::cfg_hide
1031                         | sym::hidden
1032                         | sym::html_favicon_url
1033                         | sym::html_logo_url
1034                         | sym::html_no_source
1035                         | sym::html_playground_url
1036                         | sym::html_root_url
1037                         | sym::inline
1038                         | sym::issue_tracker_base_url
1039                         | sym::keyword
1040                         | sym::masked
1041                         | sym::no_default_passes
1042                         | sym::no_inline
1043                         | sym::notable_trait
1044                         | sym::passes
1045                         | sym::plugins
1046                         | sym::fake_variadic => {}
1047
1048                         sym::test => {
1049                             if !self.check_test_attr(meta, hir_id) {
1050                                 is_valid = false;
1051                             }
1052                         }
1053
1054                         sym::primitive => {
1055                             if !self.tcx.features().rustdoc_internals {
1056                                 self.tcx.emit_spanned_lint(
1057                                     INVALID_DOC_ATTRIBUTES,
1058                                     hir_id,
1059                                     i_meta.span,
1060                                     errors::DocPrimitive,
1061                                 );
1062                             }
1063                         }
1064
1065                         _ => {
1066                             let path = rustc_ast_pretty::pprust::path_to_string(&i_meta.path);
1067                             if i_meta.has_name(sym::spotlight) {
1068                                 self.tcx.emit_spanned_lint(
1069                                     INVALID_DOC_ATTRIBUTES,
1070                                     hir_id,
1071                                     i_meta.span,
1072                                     errors::DocTestUnknownSpotlight {
1073                                         path,
1074                                         span: i_meta.span
1075                                     }
1076                                 );
1077                             } else if i_meta.has_name(sym::include) &&
1078                                     let Some(value) = i_meta.value_str() {
1079                                 let applicability = if list.len() == 1 {
1080                                     Applicability::MachineApplicable
1081                                 } else {
1082                                     Applicability::MaybeIncorrect
1083                                 };
1084                                 // If there are multiple attributes, the suggestion would suggest
1085                                 // deleting all of them, which is incorrect.
1086                                 self.tcx.emit_spanned_lint(
1087                                     INVALID_DOC_ATTRIBUTES,
1088                                     hir_id,
1089                                     i_meta.span,
1090                                     errors::DocTestUnknownInclude {
1091                                         path,
1092                                         value: value.to_string(),
1093                                         inner: (attr.style == AttrStyle::Inner)
1094                                             .then_some("!")
1095                                             .unwrap_or(""),
1096                                         sugg: (attr.meta().unwrap().span, applicability),
1097                                     }
1098                                 );
1099                             } else {
1100                                 self.tcx.emit_spanned_lint(
1101                                     INVALID_DOC_ATTRIBUTES,
1102                                     hir_id,
1103                                     i_meta.span,
1104                                     errors::DocTestUnknownAny { path }
1105                                 );
1106                             }
1107                             is_valid = false;
1108                         }
1109                     }
1110                 } else {
1111                     self.tcx.emit_spanned_lint(
1112                         INVALID_DOC_ATTRIBUTES,
1113                         hir_id,
1114                         meta.span(),
1115                         errors::DocInvalid,
1116                     );
1117                     is_valid = false;
1118                 }
1119             }
1120         }
1121
1122         is_valid
1123     }
1124
1125     /// Warns against some misuses of `#[pass_by_value]`
1126     fn check_pass_by_value(&self, attr: &Attribute, span: Span, target: Target) -> bool {
1127         match target {
1128             Target::Struct | Target::Enum | Target::TyAlias => true,
1129             _ => {
1130                 self.tcx.sess.emit_err(errors::PassByValue { attr_span: attr.span, span });
1131                 false
1132             }
1133         }
1134     }
1135
1136     fn check_allow_incoherent_impl(&self, attr: &Attribute, span: Span, target: Target) -> bool {
1137         match target {
1138             Target::Method(MethodKind::Inherent) => true,
1139             _ => {
1140                 self.tcx.sess.emit_err(errors::AllowIncoherentImpl { attr_span: attr.span, span });
1141                 false
1142             }
1143         }
1144     }
1145
1146     fn check_has_incoherent_inherent_impls(
1147         &self,
1148         attr: &Attribute,
1149         span: Span,
1150         target: Target,
1151     ) -> bool {
1152         match target {
1153             Target::Trait | Target::Struct | Target::Enum | Target::Union | Target::ForeignTy => {
1154                 true
1155             }
1156             _ => {
1157                 self.tcx
1158                     .sess
1159                     .emit_err(errors::HasIncoherentInherentImpl { attr_span: attr.span, span });
1160                 false
1161             }
1162         }
1163     }
1164
1165     /// Warns against some misuses of `#[must_use]`
1166     fn check_must_use(&self, hir_id: HirId, attr: &Attribute, target: Target) -> bool {
1167         if !matches!(
1168             target,
1169             Target::Fn
1170                 | Target::Enum
1171                 | Target::Struct
1172                 | Target::Union
1173                 | Target::Method(_)
1174                 | Target::ForeignFn
1175                 // `impl Trait` in return position can trip
1176                 // `unused_must_use` if `Trait` is marked as
1177                 // `#[must_use]`
1178                 | Target::Trait
1179         ) {
1180             let article = match target {
1181                 Target::ExternCrate
1182                 | Target::OpaqueTy
1183                 | Target::Enum
1184                 | Target::Impl
1185                 | Target::Expression
1186                 | Target::Arm
1187                 | Target::AssocConst
1188                 | Target::AssocTy => "an",
1189                 _ => "a",
1190             };
1191
1192             self.tcx.emit_spanned_lint(
1193                 UNUSED_ATTRIBUTES,
1194                 hir_id,
1195                 attr.span,
1196                 errors::MustUseNoEffect { article, target },
1197             );
1198         }
1199
1200         // For now, its always valid
1201         true
1202     }
1203
1204     /// Checks if `#[must_not_suspend]` is applied to a function. Returns `true` if valid.
1205     fn check_must_not_suspend(&self, attr: &Attribute, span: Span, target: Target) -> bool {
1206         match target {
1207             Target::Struct | Target::Enum | Target::Union | Target::Trait => true,
1208             _ => {
1209                 self.tcx.sess.emit_err(errors::MustNotSuspend { attr_span: attr.span, span });
1210                 false
1211             }
1212         }
1213     }
1214
1215     /// Checks if `#[cold]` is applied to a non-function. Returns `true` if valid.
1216     fn check_cold(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
1217         match target {
1218             Target::Fn | Target::Method(..) | Target::ForeignFn | Target::Closure => {}
1219             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
1220             // `#[cold]` attribute with just a lint, because we previously
1221             // erroneously allowed it and some crates used it accidentally, to be compatible
1222             // with crates depending on them, we can't throw an error here.
1223             Target::Field | Target::Arm | Target::MacroDef => {
1224                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "cold");
1225             }
1226             _ => {
1227                 // FIXME: #[cold] was previously allowed on non-functions and some crates used
1228                 // this, so only emit a warning.
1229                 self.tcx.emit_spanned_lint(
1230                     UNUSED_ATTRIBUTES,
1231                     hir_id,
1232                     attr.span,
1233                     errors::Cold { span, on_crate: hir_id == CRATE_HIR_ID },
1234                 );
1235             }
1236         }
1237     }
1238
1239     /// Checks if `#[link]` is applied to an item other than a foreign module.
1240     fn check_link(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
1241         if target == Target::ForeignMod
1242             && let hir::Node::Item(item) = self.tcx.hir().get(hir_id)
1243             && let Item { kind: ItemKind::ForeignMod { abi, .. }, .. } = item
1244             && !matches!(abi, Abi::Rust | Abi::RustIntrinsic | Abi::PlatformIntrinsic)
1245         {
1246             return;
1247         }
1248
1249         self.tcx.emit_spanned_lint(
1250             UNUSED_ATTRIBUTES,
1251             hir_id,
1252             attr.span,
1253             errors::Link { span: (target != Target::ForeignMod).then_some(span) },
1254         );
1255     }
1256
1257     /// Checks if `#[link_name]` is applied to an item other than a foreign function or static.
1258     fn check_link_name(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
1259         match target {
1260             Target::ForeignFn | Target::ForeignStatic => {}
1261             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
1262             // `#[link_name]` attribute with just a lint, because we previously
1263             // erroneously allowed it and some crates used it accidentally, to be compatible
1264             // with crates depending on them, we can't throw an error here.
1265             Target::Field | Target::Arm | Target::MacroDef => {
1266                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "link_name");
1267             }
1268             _ => {
1269                 // FIXME: #[cold] was previously allowed on non-functions/statics and some crates
1270                 // used this, so only emit a warning.
1271                 let attr_span = matches!(target, Target::ForeignMod).then_some(attr.span);
1272                 if let Some(s) = attr.value_str() {
1273                     self.tcx.emit_spanned_lint(
1274                         UNUSED_ATTRIBUTES,
1275                         hir_id,
1276                         attr.span,
1277                         errors::LinkName { span, attr_span, value: s.as_str() },
1278                     );
1279                 } else {
1280                     self.tcx.emit_spanned_lint(
1281                         UNUSED_ATTRIBUTES,
1282                         hir_id,
1283                         attr.span,
1284                         errors::LinkName { span, attr_span, value: "..." },
1285                     );
1286                 };
1287             }
1288         }
1289     }
1290
1291     /// Checks if `#[no_link]` is applied to an `extern crate`. Returns `true` if valid.
1292     fn check_no_link(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) -> bool {
1293         match target {
1294             Target::ExternCrate => true,
1295             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
1296             // `#[no_link]` attribute with just a lint, because we previously
1297             // erroneously allowed it and some crates used it accidentally, to be compatible
1298             // with crates depending on them, we can't throw an error here.
1299             Target::Field | Target::Arm | Target::MacroDef => {
1300                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "no_link");
1301                 true
1302             }
1303             _ => {
1304                 self.tcx.sess.emit_err(errors::NoLink { attr_span: attr.span, span });
1305                 false
1306             }
1307         }
1308     }
1309
1310     fn is_impl_item(&self, hir_id: HirId) -> bool {
1311         matches!(self.tcx.hir().get(hir_id), hir::Node::ImplItem(..))
1312     }
1313
1314     /// Checks if `#[export_name]` is applied to a function or static. Returns `true` if valid.
1315     fn check_export_name(
1316         &self,
1317         hir_id: HirId,
1318         attr: &Attribute,
1319         span: Span,
1320         target: Target,
1321     ) -> bool {
1322         match target {
1323             Target::Static | Target::Fn => true,
1324             Target::Method(..) if self.is_impl_item(hir_id) => true,
1325             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
1326             // `#[export_name]` attribute with just a lint, because we previously
1327             // erroneously allowed it and some crates used it accidentally, to be compatible
1328             // with crates depending on them, we can't throw an error here.
1329             Target::Field | Target::Arm | Target::MacroDef => {
1330                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "export_name");
1331                 true
1332             }
1333             _ => {
1334                 self.tcx.sess.emit_err(errors::ExportName { attr_span: attr.span, span });
1335                 false
1336             }
1337         }
1338     }
1339
1340     fn check_rustc_layout_scalar_valid_range(
1341         &self,
1342         attr: &Attribute,
1343         span: Span,
1344         target: Target,
1345     ) -> bool {
1346         if target != Target::Struct {
1347             self.tcx.sess.emit_err(errors::RustcLayoutScalarValidRangeNotStruct {
1348                 attr_span: attr.span,
1349                 span,
1350             });
1351             return false;
1352         }
1353
1354         let Some(list) = attr.meta_item_list() else {
1355             return false;
1356         };
1357
1358         if matches!(
1359             &list[..],
1360             &[NestedMetaItem::Literal(MetaItemLit { kind: LitKind::Int(..), .. })]
1361         ) {
1362             true
1363         } else {
1364             self.tcx.sess.emit_err(errors::RustcLayoutScalarValidRangeArg { attr_span: attr.span });
1365             false
1366         }
1367     }
1368
1369     /// Checks if `#[rustc_legacy_const_generics]` is applied to a function and has a valid argument.
1370     fn check_rustc_legacy_const_generics(
1371         &self,
1372         hir_id: HirId,
1373         attr: &Attribute,
1374         span: Span,
1375         target: Target,
1376         item: Option<ItemLike<'_>>,
1377     ) -> bool {
1378         let is_function = matches!(target, Target::Fn);
1379         if !is_function {
1380             self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
1381                 attr_span: attr.span,
1382                 defn_span: span,
1383                 on_crate: hir_id == CRATE_HIR_ID,
1384             });
1385             return false;
1386         }
1387
1388         let Some(list) = attr.meta_item_list() else {
1389             // The attribute form is validated on AST.
1390             return false;
1391         };
1392
1393         let Some(ItemLike::Item(Item {
1394             kind: ItemKind::Fn(FnSig { decl, .. }, generics, _),
1395             ..
1396         }))  = item else {
1397             bug!("should be a function item");
1398         };
1399
1400         for param in generics.params {
1401             match param.kind {
1402                 hir::GenericParamKind::Const { .. } => {}
1403                 _ => {
1404                     self.tcx.sess.emit_err(errors::RustcLegacyConstGenericsOnly {
1405                         attr_span: attr.span,
1406                         param_span: param.span,
1407                     });
1408                     return false;
1409                 }
1410             }
1411         }
1412
1413         if list.len() != generics.params.len() {
1414             self.tcx.sess.emit_err(errors::RustcLegacyConstGenericsIndex {
1415                 attr_span: attr.span,
1416                 generics_span: generics.span,
1417             });
1418             return false;
1419         }
1420
1421         let arg_count = decl.inputs.len() as u128 + generics.params.len() as u128;
1422         let mut invalid_args = vec![];
1423         for meta in list {
1424             if let Some(LitKind::Int(val, _)) = meta.literal().map(|lit| &lit.kind) {
1425                 if *val >= arg_count {
1426                     let span = meta.span();
1427                     self.tcx.sess.emit_err(errors::RustcLegacyConstGenericsIndexExceed {
1428                         span,
1429                         arg_count: arg_count as usize,
1430                     });
1431                     return false;
1432                 }
1433             } else {
1434                 invalid_args.push(meta.span());
1435             }
1436         }
1437
1438         if !invalid_args.is_empty() {
1439             self.tcx.sess.emit_err(errors::RustcLegacyConstGenericsIndexNegative { invalid_args });
1440             false
1441         } else {
1442             true
1443         }
1444     }
1445
1446     /// Helper function for checking that the provided attribute is only applied to a function or
1447     /// method.
1448     fn check_applied_to_fn_or_method(
1449         &self,
1450         hir_id: HirId,
1451         attr: &Attribute,
1452         span: Span,
1453         target: Target,
1454     ) -> bool {
1455         let is_function = matches!(target, Target::Fn | Target::Method(..));
1456         if !is_function {
1457             self.tcx.sess.emit_err(errors::AttrShouldBeAppliedToFn {
1458                 attr_span: attr.span,
1459                 defn_span: span,
1460                 on_crate: hir_id == CRATE_HIR_ID,
1461             });
1462             false
1463         } else {
1464             true
1465         }
1466     }
1467
1468     /// Checks that the `#[rustc_lint_query_instability]` attribute is only applied to a function
1469     /// or method.
1470     fn check_rustc_lint_query_instability(
1471         &self,
1472         hir_id: HirId,
1473         attr: &Attribute,
1474         span: Span,
1475         target: Target,
1476     ) -> bool {
1477         self.check_applied_to_fn_or_method(hir_id, attr, span, target)
1478     }
1479
1480     /// Checks that the `#[rustc_lint_diagnostics]` attribute is only applied to a function or
1481     /// method.
1482     fn check_rustc_lint_diagnostics(
1483         &self,
1484         hir_id: HirId,
1485         attr: &Attribute,
1486         span: Span,
1487         target: Target,
1488     ) -> bool {
1489         self.check_applied_to_fn_or_method(hir_id, attr, span, target)
1490     }
1491
1492     /// Checks that the `#[rustc_lint_opt_ty]` attribute is only applied to a struct.
1493     fn check_rustc_lint_opt_ty(&self, attr: &Attribute, span: Span, target: Target) -> bool {
1494         match target {
1495             Target::Struct => true,
1496             _ => {
1497                 self.tcx.sess.emit_err(errors::RustcLintOptTy { attr_span: attr.span, span });
1498                 false
1499             }
1500         }
1501     }
1502
1503     /// Checks that the `#[rustc_lint_opt_deny_field_access]` attribute is only applied to a field.
1504     fn check_rustc_lint_opt_deny_field_access(
1505         &self,
1506         attr: &Attribute,
1507         span: Span,
1508         target: Target,
1509     ) -> bool {
1510         match target {
1511             Target::Field => true,
1512             _ => {
1513                 self.tcx
1514                     .sess
1515                     .emit_err(errors::RustcLintOptDenyFieldAccess { attr_span: attr.span, span });
1516                 false
1517             }
1518         }
1519     }
1520
1521     /// Checks that the dep-graph debugging attributes are only present when the query-dep-graph
1522     /// option is passed to the compiler.
1523     fn check_rustc_dirty_clean(&self, attr: &Attribute) -> bool {
1524         if self.tcx.sess.opts.unstable_opts.query_dep_graph {
1525             true
1526         } else {
1527             self.tcx.sess.emit_err(errors::RustcDirtyClean { span: attr.span });
1528             false
1529         }
1530     }
1531
1532     /// Checks if `#[link_section]` is applied to a function or static.
1533     fn check_link_section(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
1534         match target {
1535             Target::Static | Target::Fn | Target::Method(..) => {}
1536             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
1537             // `#[link_section]` attribute with just a lint, because we previously
1538             // erroneously allowed it and some crates used it accidentally, to be compatible
1539             // with crates depending on them, we can't throw an error here.
1540             Target::Field | Target::Arm | Target::MacroDef => {
1541                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "link_section");
1542             }
1543             _ => {
1544                 // FIXME: #[link_section] was previously allowed on non-functions/statics and some
1545                 // crates used this, so only emit a warning.
1546                 self.tcx.emit_spanned_lint(
1547                     UNUSED_ATTRIBUTES,
1548                     hir_id,
1549                     attr.span,
1550                     errors::LinkSection { span },
1551                 );
1552             }
1553         }
1554     }
1555
1556     /// Checks if `#[no_mangle]` is applied to a function or static.
1557     fn check_no_mangle(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
1558         match target {
1559             Target::Static | Target::Fn => {}
1560             Target::Method(..) if self.is_impl_item(hir_id) => {}
1561             // FIXME(#80564): We permit struct fields, match arms and macro defs to have an
1562             // `#[no_mangle]` attribute with just a lint, because we previously
1563             // erroneously allowed it and some crates used it accidentally, to be compatible
1564             // with crates depending on them, we can't throw an error here.
1565             Target::Field | Target::Arm | Target::MacroDef => {
1566                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "no_mangle");
1567             }
1568             // FIXME: #[no_mangle] was previously allowed on non-functions/statics, this should be an error
1569             // The error should specify that the item that is wrong is specifically a *foreign* fn/static
1570             // otherwise the error seems odd
1571             Target::ForeignFn | Target::ForeignStatic => {
1572                 let foreign_item_kind = match target {
1573                     Target::ForeignFn => "function",
1574                     Target::ForeignStatic => "static",
1575                     _ => unreachable!(),
1576                 };
1577                 self.tcx.emit_spanned_lint(
1578                     UNUSED_ATTRIBUTES,
1579                     hir_id,
1580                     attr.span,
1581                     errors::NoMangleForeign { span, attr_span: attr.span, foreign_item_kind },
1582                 );
1583             }
1584             _ => {
1585                 // FIXME: #[no_mangle] was previously allowed on non-functions/statics and some
1586                 // crates used this, so only emit a warning.
1587                 self.tcx.emit_spanned_lint(
1588                     UNUSED_ATTRIBUTES,
1589                     hir_id,
1590                     attr.span,
1591                     errors::NoMangle { span },
1592                 );
1593             }
1594         }
1595     }
1596
1597     /// Checks if the `#[repr]` attributes on `item` are valid.
1598     fn check_repr(
1599         &self,
1600         attrs: &[Attribute],
1601         span: Span,
1602         target: Target,
1603         item: Option<ItemLike<'_>>,
1604         hir_id: HirId,
1605     ) {
1606         // Extract the names of all repr hints, e.g., [foo, bar, align] for:
1607         // ```
1608         // #[repr(foo)]
1609         // #[repr(bar, align(8))]
1610         // ```
1611         let hints: Vec<_> = attrs
1612             .iter()
1613             .filter(|attr| attr.has_name(sym::repr))
1614             .filter_map(|attr| attr.meta_item_list())
1615             .flatten()
1616             .collect();
1617
1618         let mut int_reprs = 0;
1619         let mut is_c = false;
1620         let mut is_simd = false;
1621         let mut is_transparent = false;
1622
1623         for hint in &hints {
1624             if !hint.is_meta_item() {
1625                 self.tcx.sess.emit_err(errors::ReprIdent { span: hint.span() });
1626                 continue;
1627             }
1628
1629             match hint.name_or_empty() {
1630                 sym::C => {
1631                     is_c = true;
1632                     match target {
1633                         Target::Struct | Target::Union | Target::Enum => continue,
1634                         _ => {
1635                             self.tcx.sess.emit_err(AttrApplication::StructEnumUnion {
1636                                 hint_span: hint.span(),
1637                                 span,
1638                             });
1639                         }
1640                     }
1641                 }
1642                 sym::align => {
1643                     if let (Target::Fn, false) = (target, self.tcx.features().fn_align) {
1644                         feature_err(
1645                             &self.tcx.sess.parse_sess,
1646                             sym::fn_align,
1647                             hint.span(),
1648                             "`repr(align)` attributes on functions are unstable",
1649                         )
1650                         .emit();
1651                     }
1652
1653                     match target {
1654                         Target::Struct | Target::Union | Target::Enum | Target::Fn => continue,
1655                         _ => {
1656                             self.tcx.sess.emit_err(AttrApplication::StructEnumFunctionUnion {
1657                                 hint_span: hint.span(),
1658                                 span,
1659                             });
1660                         }
1661                     }
1662                 }
1663                 sym::packed => {
1664                     if target != Target::Struct && target != Target::Union {
1665                         self.tcx.sess.emit_err(AttrApplication::StructUnion {
1666                             hint_span: hint.span(),
1667                             span,
1668                         });
1669                     } else {
1670                         continue;
1671                     }
1672                 }
1673                 sym::simd => {
1674                     is_simd = true;
1675                     if target != Target::Struct {
1676                         self.tcx
1677                             .sess
1678                             .emit_err(AttrApplication::Struct { hint_span: hint.span(), span });
1679                     } else {
1680                         continue;
1681                     }
1682                 }
1683                 sym::transparent => {
1684                     is_transparent = true;
1685                     match target {
1686                         Target::Struct | Target::Union | Target::Enum => continue,
1687                         _ => {
1688                             self.tcx.sess.emit_err(AttrApplication::StructEnumUnion {
1689                                 hint_span: hint.span(),
1690                                 span,
1691                             });
1692                         }
1693                     }
1694                 }
1695                 sym::i8
1696                 | sym::u8
1697                 | sym::i16
1698                 | sym::u16
1699                 | sym::i32
1700                 | sym::u32
1701                 | sym::i64
1702                 | sym::u64
1703                 | sym::i128
1704                 | sym::u128
1705                 | sym::isize
1706                 | sym::usize => {
1707                     int_reprs += 1;
1708                     if target != Target::Enum {
1709                         self.tcx
1710                             .sess
1711                             .emit_err(AttrApplication::Enum { hint_span: hint.span(), span });
1712                     } else {
1713                         continue;
1714                     }
1715                 }
1716                 _ => {
1717                     self.tcx.sess.emit_err(UnrecognizedReprHint { span: hint.span() });
1718                     continue;
1719                 }
1720             };
1721         }
1722
1723         // Just point at all repr hints if there are any incompatibilities.
1724         // This is not ideal, but tracking precisely which ones are at fault is a huge hassle.
1725         let hint_spans = hints.iter().map(|hint| hint.span());
1726
1727         // Error on repr(transparent, <anything else>).
1728         if is_transparent && hints.len() > 1 {
1729             let hint_spans: Vec<_> = hint_spans.clone().collect();
1730             self.tcx
1731                 .sess
1732                 .emit_err(TransparentIncompatible { hint_spans, target: target.to_string() });
1733         }
1734         // Warn on repr(u8, u16), repr(C, simd), and c-like-enum-repr(C, u8)
1735         if (int_reprs > 1)
1736             || (is_simd && is_c)
1737             || (int_reprs == 1
1738                 && is_c
1739                 && item.map_or(false, |item| {
1740                     if let ItemLike::Item(item) = item {
1741                         return is_c_like_enum(item);
1742                     }
1743                     return false;
1744                 }))
1745         {
1746             self.tcx.emit_spanned_lint(
1747                 CONFLICTING_REPR_HINTS,
1748                 hir_id,
1749                 hint_spans.collect::<Vec<Span>>(),
1750                 errors::ReprConflicting,
1751             );
1752         }
1753     }
1754
1755     fn check_used(&self, attrs: &[Attribute], target: Target) {
1756         let mut used_linker_span = None;
1757         let mut used_compiler_span = None;
1758         for attr in attrs.iter().filter(|attr| attr.has_name(sym::used)) {
1759             if target != Target::Static {
1760                 self.tcx.sess.emit_err(errors::UsedStatic { span: attr.span });
1761             }
1762             let inner = attr.meta_item_list();
1763             match inner.as_deref() {
1764                 Some([item]) if item.has_name(sym::linker) => {
1765                     if used_linker_span.is_none() {
1766                         used_linker_span = Some(attr.span);
1767                     }
1768                 }
1769                 Some([item]) if item.has_name(sym::compiler) => {
1770                     if used_compiler_span.is_none() {
1771                         used_compiler_span = Some(attr.span);
1772                     }
1773                 }
1774                 Some(_) => {
1775                     // This error case is handled in rustc_hir_analysis::collect.
1776                 }
1777                 None => {
1778                     // Default case (compiler) when arg isn't defined.
1779                     if used_compiler_span.is_none() {
1780                         used_compiler_span = Some(attr.span);
1781                     }
1782                 }
1783             }
1784         }
1785         if let (Some(linker_span), Some(compiler_span)) = (used_linker_span, used_compiler_span) {
1786             self.tcx
1787                 .sess
1788                 .emit_err(errors::UsedCompilerLinker { spans: vec![linker_span, compiler_span] });
1789         }
1790     }
1791
1792     /// Outputs an error for `#[allow_internal_unstable]` which can only be applied to macros.
1793     /// (Allows proc_macro functions)
1794     fn check_allow_internal_unstable(
1795         &self,
1796         hir_id: HirId,
1797         attr: &Attribute,
1798         span: Span,
1799         target: Target,
1800         attrs: &[Attribute],
1801     ) -> bool {
1802         debug!("Checking target: {:?}", target);
1803         match target {
1804             Target::Fn => {
1805                 for attr in attrs {
1806                     if self.tcx.sess.is_proc_macro_attr(attr) {
1807                         debug!("Is proc macro attr");
1808                         return true;
1809                     }
1810                 }
1811                 debug!("Is not proc macro attr");
1812                 false
1813             }
1814             Target::MacroDef => true,
1815             // FIXME(#80564): We permit struct fields and match arms to have an
1816             // `#[allow_internal_unstable]` attribute with just a lint, because we previously
1817             // erroneously allowed it and some crates used it accidentally, to be compatible
1818             // with crates depending on them, we can't throw an error here.
1819             Target::Field | Target::Arm => {
1820                 self.inline_attr_str_error_without_macro_def(
1821                     hir_id,
1822                     attr,
1823                     "allow_internal_unstable",
1824                 );
1825                 true
1826             }
1827             _ => {
1828                 self.tcx
1829                     .sess
1830                     .emit_err(errors::AllowInternalUnstable { attr_span: attr.span, span });
1831                 false
1832             }
1833         }
1834     }
1835
1836     /// Checks if the items on the `#[debugger_visualizer]` attribute are valid.
1837     fn check_debugger_visualizer(&self, attr: &Attribute, target: Target) -> bool {
1838         match target {
1839             Target::Mod => {}
1840             _ => {
1841                 self.tcx.sess.emit_err(errors::DebugVisualizerPlacement { span: attr.span });
1842                 return false;
1843             }
1844         }
1845
1846         let Some(hints) = attr.meta_item_list() else {
1847             self.tcx.sess.emit_err(errors::DebugVisualizerInvalid { span: attr.span });
1848             return false;
1849         };
1850
1851         let hint = match hints.len() {
1852             1 => &hints[0],
1853             _ => {
1854                 self.tcx.sess.emit_err(errors::DebugVisualizerInvalid { span: attr.span });
1855                 return false;
1856             }
1857         };
1858
1859         let Some(meta_item) = hint.meta_item() else {
1860             self.tcx.sess.emit_err(errors::DebugVisualizerInvalid { span: attr.span });
1861             return false;
1862         };
1863
1864         let visualizer_path = match (meta_item.name_or_empty(), meta_item.value_str()) {
1865             (sym::natvis_file, Some(value)) => value,
1866             (sym::gdb_script_file, Some(value)) => value,
1867             (_, _) => {
1868                 self.tcx.sess.emit_err(errors::DebugVisualizerInvalid { span: meta_item.span });
1869                 return false;
1870             }
1871         };
1872
1873         let file =
1874             match resolve_path(&self.tcx.sess.parse_sess, visualizer_path.as_str(), attr.span) {
1875                 Ok(file) => file,
1876                 Err(mut err) => {
1877                     err.emit();
1878                     return false;
1879                 }
1880             };
1881
1882         match std::fs::File::open(&file) {
1883             Ok(_) => true,
1884             Err(error) => {
1885                 self.tcx.sess.emit_err(DebugVisualizerUnreadable {
1886                     span: meta_item.span,
1887                     file: &file,
1888                     error,
1889                 });
1890                 false
1891             }
1892         }
1893     }
1894
1895     /// Outputs an error for `#[allow_internal_unstable]` which can only be applied to macros.
1896     /// (Allows proc_macro functions)
1897     fn check_rustc_allow_const_fn_unstable(
1898         &self,
1899         hir_id: HirId,
1900         attr: &Attribute,
1901         span: Span,
1902         target: Target,
1903     ) -> bool {
1904         match target {
1905             Target::Fn | Target::Method(_)
1906                 if self.tcx.is_const_fn_raw(self.tcx.hir().local_def_id(hir_id).to_def_id()) =>
1907             {
1908                 true
1909             }
1910             // FIXME(#80564): We permit struct fields and match arms to have an
1911             // `#[allow_internal_unstable]` attribute with just a lint, because we previously
1912             // erroneously allowed it and some crates used it accidentally, to be compatible
1913             // with crates depending on them, we can't throw an error here.
1914             Target::Field | Target::Arm | Target::MacroDef => {
1915                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "allow_internal_unstable");
1916                 true
1917             }
1918             _ => {
1919                 self.tcx
1920                     .sess
1921                     .emit_err(errors::RustcAllowConstFnUnstable { attr_span: attr.span, span });
1922                 false
1923             }
1924         }
1925     }
1926
1927     fn check_rustc_std_internal_symbol(
1928         &self,
1929         attr: &Attribute,
1930         span: Span,
1931         target: Target,
1932     ) -> bool {
1933         match target {
1934             Target::Fn | Target::Static => true,
1935             _ => {
1936                 self.tcx
1937                     .sess
1938                     .emit_err(errors::RustcStdInternalSymbol { attr_span: attr.span, span });
1939                 false
1940             }
1941         }
1942     }
1943
1944     /// `#[const_trait]` only applies to traits.
1945     fn check_const_trait(&self, attr: &Attribute, _span: Span, target: Target) -> bool {
1946         match target {
1947             Target::Trait => true,
1948             _ => {
1949                 self.tcx.sess.emit_err(errors::ConstTrait { attr_span: attr.span });
1950                 false
1951             }
1952         }
1953     }
1954
1955     fn check_stability_promotable(&self, attr: &Attribute, _span: Span, target: Target) -> bool {
1956         match target {
1957             Target::Expression => {
1958                 self.tcx.sess.emit_err(errors::StabilityPromotable { attr_span: attr.span });
1959                 false
1960             }
1961             _ => true,
1962         }
1963     }
1964
1965     fn check_link_ordinal(&self, attr: &Attribute, _span: Span, target: Target) -> bool {
1966         match target {
1967             Target::ForeignFn | Target::ForeignStatic => true,
1968             _ => {
1969                 self.tcx.sess.emit_err(errors::LinkOrdinal { attr_span: attr.span });
1970                 false
1971             }
1972         }
1973     }
1974
1975     fn check_deprecated(&self, hir_id: HirId, attr: &Attribute, _span: Span, target: Target) {
1976         match target {
1977             Target::Closure | Target::Expression | Target::Statement | Target::Arm => {
1978                 self.tcx.emit_spanned_lint(
1979                     UNUSED_ATTRIBUTES,
1980                     hir_id,
1981                     attr.span,
1982                     errors::Deprecated,
1983                 );
1984             }
1985             _ => {}
1986         }
1987     }
1988
1989     fn check_macro_use(&self, hir_id: HirId, attr: &Attribute, target: Target) {
1990         let name = attr.name_or_empty();
1991         match target {
1992             Target::ExternCrate | Target::Mod => {}
1993             _ => {
1994                 self.tcx.emit_spanned_lint(
1995                     UNUSED_ATTRIBUTES,
1996                     hir_id,
1997                     attr.span,
1998                     errors::MacroUse { name },
1999                 );
2000             }
2001         }
2002     }
2003
2004     fn check_macro_export(&self, hir_id: HirId, attr: &Attribute, target: Target) {
2005         if target != Target::MacroDef {
2006             self.tcx.emit_spanned_lint(UNUSED_ATTRIBUTES, hir_id, attr.span, errors::MacroExport);
2007         }
2008     }
2009
2010     fn check_plugin_registrar(&self, hir_id: HirId, attr: &Attribute, target: Target) {
2011         if target != Target::Fn {
2012             self.tcx.emit_spanned_lint(
2013                 UNUSED_ATTRIBUTES,
2014                 hir_id,
2015                 attr.span,
2016                 errors::PluginRegistrar,
2017             );
2018         }
2019     }
2020
2021     fn check_unused_attribute(&self, hir_id: HirId, attr: &Attribute) {
2022         // Warn on useless empty attributes.
2023         let note = if matches!(
2024             attr.name_or_empty(),
2025             sym::macro_use
2026                 | sym::allow
2027                 | sym::expect
2028                 | sym::warn
2029                 | sym::deny
2030                 | sym::forbid
2031                 | sym::feature
2032                 | sym::repr
2033                 | sym::target_feature
2034         ) && attr.meta_item_list().map_or(false, |list| list.is_empty())
2035         {
2036             errors::UnusedNote::EmptyList { name: attr.name_or_empty() }
2037         } else if matches!(
2038                 attr.name_or_empty(),
2039                 sym::allow | sym::warn | sym::deny | sym::forbid | sym::expect
2040             ) && let Some(meta) = attr.meta_item_list()
2041             && meta.len() == 1
2042             && let Some(item) = meta[0].meta_item()
2043             && let MetaItemKind::NameValue(_) = &item.kind
2044             && item.path == sym::reason
2045         {
2046             errors::UnusedNote::NoLints { name: attr.name_or_empty() }
2047         } else if attr.name_or_empty() == sym::default_method_body_is_const {
2048             errors::UnusedNote::DefaultMethodBodyConst
2049         } else {
2050             return;
2051         };
2052
2053         self.tcx.emit_spanned_lint(
2054             UNUSED_ATTRIBUTES,
2055             hir_id,
2056             attr.span,
2057             errors::Unused { attr_span: attr.span, note },
2058         );
2059     }
2060 }
2061
2062 impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
2063     type NestedFilter = nested_filter::OnlyBodies;
2064
2065     fn nested_visit_map(&mut self) -> Self::Map {
2066         self.tcx.hir()
2067     }
2068
2069     fn visit_item(&mut self, item: &'tcx Item<'tcx>) {
2070         // Historically we've run more checks on non-exported than exported macros,
2071         // so this lets us continue to run them while maintaining backwards compatibility.
2072         // In the long run, the checks should be harmonized.
2073         if let ItemKind::Macro(ref macro_def, _) = item.kind {
2074             let def_id = item.owner_id.to_def_id();
2075             if macro_def.macro_rules && !self.tcx.has_attr(def_id, sym::macro_export) {
2076                 check_non_exported_macro_for_invalid_attrs(self.tcx, item);
2077             }
2078         }
2079
2080         let target = Target::from_item(item);
2081         self.check_attributes(item.hir_id(), item.span, target, Some(ItemLike::Item(item)));
2082         intravisit::walk_item(self, item)
2083     }
2084
2085     fn visit_generic_param(&mut self, generic_param: &'tcx hir::GenericParam<'tcx>) {
2086         let target = Target::from_generic_param(generic_param);
2087         self.check_attributes(generic_param.hir_id, generic_param.span, target, None);
2088         intravisit::walk_generic_param(self, generic_param)
2089     }
2090
2091     fn visit_trait_item(&mut self, trait_item: &'tcx TraitItem<'tcx>) {
2092         let target = Target::from_trait_item(trait_item);
2093         self.check_attributes(trait_item.hir_id(), trait_item.span, target, None);
2094         intravisit::walk_trait_item(self, trait_item)
2095     }
2096
2097     fn visit_field_def(&mut self, struct_field: &'tcx hir::FieldDef<'tcx>) {
2098         self.check_attributes(struct_field.hir_id, struct_field.span, Target::Field, None);
2099         intravisit::walk_field_def(self, struct_field);
2100     }
2101
2102     fn visit_arm(&mut self, arm: &'tcx hir::Arm<'tcx>) {
2103         self.check_attributes(arm.hir_id, arm.span, Target::Arm, None);
2104         intravisit::walk_arm(self, arm);
2105     }
2106
2107     fn visit_foreign_item(&mut self, f_item: &'tcx ForeignItem<'tcx>) {
2108         let target = Target::from_foreign_item(f_item);
2109         self.check_attributes(f_item.hir_id(), f_item.span, target, Some(ItemLike::ForeignItem));
2110         intravisit::walk_foreign_item(self, f_item)
2111     }
2112
2113     fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
2114         let target = target_from_impl_item(self.tcx, impl_item);
2115         self.check_attributes(impl_item.hir_id(), impl_item.span, target, None);
2116         intravisit::walk_impl_item(self, impl_item)
2117     }
2118
2119     fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt<'tcx>) {
2120         // When checking statements ignore expressions, they will be checked later.
2121         if let hir::StmtKind::Local(ref l) = stmt.kind {
2122             self.check_attributes(l.hir_id, stmt.span, Target::Statement, None);
2123         }
2124         intravisit::walk_stmt(self, stmt)
2125     }
2126
2127     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
2128         let target = match expr.kind {
2129             hir::ExprKind::Closure { .. } => Target::Closure,
2130             _ => Target::Expression,
2131         };
2132
2133         self.check_attributes(expr.hir_id, expr.span, target, None);
2134         intravisit::walk_expr(self, expr)
2135     }
2136
2137     fn visit_expr_field(&mut self, field: &'tcx hir::ExprField<'tcx>) {
2138         self.check_attributes(field.hir_id, field.span, Target::ExprField, None);
2139         intravisit::walk_expr_field(self, field)
2140     }
2141
2142     fn visit_variant(&mut self, variant: &'tcx hir::Variant<'tcx>) {
2143         self.check_attributes(variant.hir_id, variant.span, Target::Variant, None);
2144         intravisit::walk_variant(self, variant)
2145     }
2146
2147     fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
2148         self.check_attributes(param.hir_id, param.span, Target::Param, None);
2149
2150         intravisit::walk_param(self, param);
2151     }
2152
2153     fn visit_pat_field(&mut self, field: &'tcx hir::PatField<'tcx>) {
2154         self.check_attributes(field.hir_id, field.span, Target::PatField, None);
2155         intravisit::walk_pat_field(self, field);
2156     }
2157 }
2158
2159 fn is_c_like_enum(item: &Item<'_>) -> bool {
2160     if let ItemKind::Enum(ref def, _) = item.kind {
2161         for variant in def.variants {
2162             match variant.data {
2163                 hir::VariantData::Unit(..) => { /* continue */ }
2164                 _ => return false,
2165             }
2166         }
2167         true
2168     } else {
2169         false
2170     }
2171 }
2172
2173 // FIXME: Fix "Cannot determine resolution" error and remove built-in macros
2174 // from this check.
2175 fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
2176     // Check for builtin attributes at the crate level
2177     // which were unsuccessfully resolved due to cannot determine
2178     // resolution for the attribute macro error.
2179     const ATTRS_TO_CHECK: &[Symbol] = &[
2180         sym::macro_export,
2181         sym::repr,
2182         sym::path,
2183         sym::automatically_derived,
2184         sym::start,
2185         sym::rustc_main,
2186         sym::unix_sigpipe,
2187         sym::derive,
2188         sym::test,
2189         sym::test_case,
2190         sym::global_allocator,
2191         sym::bench,
2192     ];
2193
2194     for attr in attrs {
2195         // This function should only be called with crate attributes
2196         // which are inner attributes always but lets check to make sure
2197         if attr.style == AttrStyle::Inner {
2198             for attr_to_check in ATTRS_TO_CHECK {
2199                 if attr.has_name(*attr_to_check) {
2200                     tcx.sess.emit_err(InvalidAttrAtCrateLevel {
2201                         span: attr.span,
2202                         snippet: tcx.sess.source_map().span_to_snippet(attr.span).ok(),
2203                         name: *attr_to_check,
2204                     });
2205                 }
2206             }
2207         }
2208     }
2209 }
2210
2211 fn check_non_exported_macro_for_invalid_attrs(tcx: TyCtxt<'_>, item: &Item<'_>) {
2212     let attrs = tcx.hir().attrs(item.hir_id());
2213
2214     for attr in attrs {
2215         if attr.has_name(sym::inline) {
2216             tcx.sess.emit_err(errors::NonExportedMacroInvalidAttrs { attr_span: attr.span });
2217         }
2218     }
2219 }
2220
2221 fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {
2222     let check_attr_visitor = &mut CheckAttrVisitor { tcx };
2223     tcx.hir().visit_item_likes_in_module(module_def_id, check_attr_visitor);
2224     if module_def_id.is_top_level_module() {
2225         check_attr_visitor.check_attributes(CRATE_HIR_ID, DUMMY_SP, Target::Mod, None);
2226         check_invalid_crate_level_attr(tcx, tcx.hir().krate_attrs());
2227     }
2228 }
2229
2230 pub(crate) fn provide(providers: &mut Providers) {
2231     *providers = Providers { check_mod_attrs, ..*providers };
2232 }
2233
2234 fn check_duplicates(
2235     tcx: TyCtxt<'_>,
2236     attr: &Attribute,
2237     hir_id: HirId,
2238     duplicates: AttributeDuplicates,
2239     seen: &mut FxHashMap<Symbol, Span>,
2240 ) {
2241     use AttributeDuplicates::*;
2242     if matches!(duplicates, WarnFollowingWordOnly) && !attr.is_word() {
2243         return;
2244     }
2245     match duplicates {
2246         DuplicatesOk => {}
2247         WarnFollowing | FutureWarnFollowing | WarnFollowingWordOnly | FutureWarnPreceding => {
2248             match seen.entry(attr.name_or_empty()) {
2249                 Entry::Occupied(mut entry) => {
2250                     let (this, other) = if matches!(duplicates, FutureWarnPreceding) {
2251                         let to_remove = entry.insert(attr.span);
2252                         (to_remove, attr.span)
2253                     } else {
2254                         (attr.span, *entry.get())
2255                     };
2256                     tcx.emit_spanned_lint(
2257                         UNUSED_ATTRIBUTES,
2258                         hir_id,
2259                         this,
2260                         errors::UnusedDuplicate {
2261                             this,
2262                             other,
2263                             warning: matches!(
2264                                 duplicates,
2265                                 FutureWarnFollowing | FutureWarnPreceding
2266                             )
2267                             .then_some(()),
2268                         },
2269                     );
2270                 }
2271                 Entry::Vacant(entry) => {
2272                     entry.insert(attr.span);
2273                 }
2274             }
2275         }
2276         ErrorFollowing | ErrorPreceding => match seen.entry(attr.name_or_empty()) {
2277             Entry::Occupied(mut entry) => {
2278                 let (this, other) = if matches!(duplicates, ErrorPreceding) {
2279                     let to_remove = entry.insert(attr.span);
2280                     (to_remove, attr.span)
2281                 } else {
2282                     (attr.span, *entry.get())
2283                 };
2284                 tcx.sess.emit_err(errors::UnusedMultiple {
2285                     this,
2286                     other,
2287                     name: attr.name_or_empty(),
2288                 });
2289             }
2290             Entry::Vacant(entry) => {
2291                 entry.insert(attr.span);
2292             }
2293         },
2294     }
2295 }