Rollup of 20 pull requests

compiler/rustc_attr_ir/src/data_structures.rs

@@ -986,9 +986,19 @@ pub enum AttributeKind {
     /// Represents `#[linkage]`.
     Linkage(Linkage, Span),
 
+    /// Represents `#[lint::as_ptr]` (used by the `dangling_pointers_from_temporaries` lint).
+    LintAsPtr,
+
     /// Represents `#[allow]`, `#[warn]`, `#[deny]`, `#[forbid]`, and `#[expect]`.
     LintCheck(ThinVec<LintCheck>),
 
+    /// Represents `#[lint::never_returns_null_ptr]` (used by the `useless_ptr_null_checks` lint).
+    LintNeverReturnsNullPtr,
+
+    /// Represents `#[lint::should_not_be_called_on_const_items]` (used by the
+    /// `const_item_interior_mutations` lint).
+    LintShouldNotBeCalledOnConstItems,
+
     /// Represents `#[loop_match]`.
     LoopMatch(Span),
 
@@ -1199,9 +1209,6 @@ pub enum AttributeKind {
     /// Represents `#[rustc_allow_lifetime_dependent_specialization]`.
     RustcAllowLifetimeDependentSpecialization,
 
-    /// Represents `#[rustc_as_ptr]` (used by the `dangling_pointers_from_temporaries` lint).
-    RustcAsPtr,
-
     /// Represents `#[rustc_assert_variance]`.
     RustcAssertVariance {
         span: Span,
@@ -1396,9 +1403,6 @@ pub enum AttributeKind {
     /// Represents `#[rustc_must_match_exhaustively]`
     RustcMustMatchExhaustively(Span),
 
-    /// Represents `#[rustc_never_returns_null_ptr]`
-    RustcNeverReturnsNullPtr,
-
     /// Represents `#[rustc_no_implicit_autorefs]`
     RustcNoImplicitAutorefs,
 

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -58,7 +58,10 @@ impl AttributeKind {
             LinkOrdinal { .. } => No,
             LinkSection { .. } => Yes, // Needed for rustdoc
             Linkage(..) => No,
+            LintAsPtr => Yes,
             LintCheck(..) => No,
+            LintNeverReturnsNullPtr => Yes,
+            LintShouldNotBeCalledOnConstItems => Yes,
             LoopMatch(..) => No,
             MacroEscape => No,
             MacroExport { .. } => Yes,
@@ -109,7 +112,6 @@ impl AttributeKind {
             RustcAllowConstFnUnstable(..) => No,
             RustcAllowIncoherentImpl(..) => No,
             RustcAllowLifetimeDependentSpecialization => No,
-            RustcAsPtr => Yes,
             RustcAssertVariance { .. } => No,
             RustcAutodiff(..) => Yes,
             RustcBodyStability { .. } => No,
@@ -167,7 +169,6 @@ impl AttributeKind {
             RustcMir(..) => Yes,
             RustcMustImplementOneOf { .. } => No,
             RustcMustMatchExhaustively(..) => Yes,
-            RustcNeverReturnsNullPtr => Yes,
             RustcNoImplicitAutorefs => Yes,
             RustcNoImplicitBounds => No,
             RustcNoMirInline => Yes,
@@ -276,7 +277,10 @@ impl AttributeKind {
                 | crate::Linkage::WeakAny
                 | crate::Linkage::WeakODR => true,
             },
+            LintAsPtr => false,
             LintCheck(_) => false,
+            LintNeverReturnsNullPtr => false,
+            LintShouldNotBeCalledOnConstItems => false,
             LoopMatch(..) => false,
             MacroEscape => false,
             MacroExport { .. } => false,
@@ -327,7 +331,6 @@ impl AttributeKind {
             RustcAllowConstFnUnstable(..) => false,
             RustcAllowIncoherentImpl(..) => false,
             RustcAllowLifetimeDependentSpecialization => false,
-            RustcAsPtr => false,
             RustcAssertVariance { .. } => false,
             RustcAutodiff(..) => false,
             RustcBodyStability { .. } => false,
@@ -385,7 +388,6 @@ impl AttributeKind {
             RustcMir(..) => false,
             RustcMustImplementOneOf { .. } => false,
             RustcMustMatchExhaustively(..) => false,
-            RustcNeverReturnsNullPtr => false,
             RustcNoImplicitAutorefs => false,
             RustcNoImplicitBounds => false,
             RustcNoMirInline => false,

compiler/rustc_attr_parsing/src/attributes/lint.rs

@@ -8,6 +8,7 @@ use thin_vec::ThinVec;
 
 use crate::attributes::{AcceptMapping, AttributeParser, AttributeStability};
 use crate::context::{AcceptContext, ExpectStringLiteral, FinalizeContext};
+use crate::diagnostics::{MalformedLintAttributeInput, MalformedLintAttributeInputHelp};
 use crate::parser::{ArgParser, MetaItemOrLitParser};
 use crate::target_checking::AllowedTargets;
 use crate::target_checking::Policy::{Allow, Warn};
@@ -36,9 +37,11 @@ impl LintParser {
                 let p = parsers.last()?.meta_item()?;
                 let nv = p.args().as_name_value()?;
                 if !p.path().word_is(sym::reason) {
-                    cx.emit_err(diagnostics::MalformedAttribute {
+                    // FIXME: We should recommend `reason` here
+                    cx.emit_err(MalformedLintAttributeInput {
                         span: p.span(),
-                        kind: diagnostics::MalformedAttributeKind::BadAttributeArgument(p.span()),
+                        help: MalformedLintAttributeInputHelp::Other { kind: kind.sym() },
+                        kind: kind.sym(),
                     });
                 } else {
                     parsers = &parsers[..(parsers.len() - 1)];
@@ -78,26 +81,28 @@ impl LintParser {
                                 nv.expect_string_literal(cx);
                             }
                             ArgParser::NameValue(_) | ArgParser::List(_) => {
-                                cx.emit_err(diagnostics::MalformedAttribute {
+                                cx.emit_err(MalformedLintAttributeInput {
                                     span: p.span(),
-                                    kind: diagnostics::MalformedAttributeKind::BadAttributeArgument(
-                                        item.span(),
-                                    ),
+                                    help: MalformedLintAttributeInputHelp::Other {
+                                        kind: kind.sym(),
+                                    },
+                                    kind: kind.sym(),
                                 });
                             }
                         }
                     }
                     MetaItemOrLitParser::Lit(lit) => {
-                        cx.emit_err(diagnostics::BadAttributeLit {
+                        cx.emit_err(MalformedLintAttributeInput {
                             span: item.span(),
                             help: if lit.kind.is_str() {
-                                diagnostics::BadAttributeLitHelp::StrLit {
+                                MalformedLintAttributeInputHelp::StrLit {
                                     sym: lit.symbol,
                                     kind: kind.sym(),
                                 }
                             } else {
-                                diagnostics::BadAttributeLitHelp::Other { kind: kind.sym() }
+                                MalformedLintAttributeInputHelp::Other { kind: kind.sym() }
                             },
+                            kind: kind.sym(),
                         });
                     }
                 }

compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs

@@ -4,9 +4,9 @@ use rustc_feature::AttributeStability;
 use super::prelude::*;
 use crate::diagnostics::RustcPubTransparent;
 
-pub(crate) struct RustcAsPtrParser;
-impl NoArgsAttributeParser for RustcAsPtrParser {
-    const PATH: &[Symbol] = &[sym::rustc_as_ptr];
+pub(crate) struct LintAsPtrParser;
+impl NoArgsAttributeParser for LintAsPtrParser {
+    const PATH: &[Symbol] = &[sym::lint, sym::as_ptr];
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
         Allow(Target::Method(MethodKind::Inherent)),
@@ -15,7 +15,23 @@ impl NoArgsAttributeParser for RustcAsPtrParser {
         Allow(Target::Method(MethodKind::TraitImpl)),
     ]);
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcAsPtr;
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::LintAsPtr;
+}
+
+pub(crate) struct LintNeverReturnsNullPtrParser;
+
+impl NoArgsAttributeParser for LintNeverReturnsNullPtrParser {
+    const PATH: &[Symbol] = &[sym::lint, sym::never_returns_null_ptr];
+    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
+        Allow(Target::Fn),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+    ]);
+    const STABILITY: AttributeStability = unstable!(rustc_attrs);
+
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::LintNeverReturnsNullPtr;
 }
 
 pub(crate) struct RustcPubTransparentParser;
@@ -53,15 +69,15 @@ impl NoArgsAttributeParser for RustcPassByValueParser {
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcPassByValue;
 }
 
-pub(crate) struct RustcShouldNotBeCalledOnConstItemsParser;
-impl NoArgsAttributeParser for RustcShouldNotBeCalledOnConstItemsParser {
-    const PATH: &[Symbol] = &[sym::rustc_should_not_be_called_on_const_items];
+pub(crate) struct LintShouldNotBeCalledOnConstItemsParser;
+impl NoArgsAttributeParser for LintShouldNotBeCalledOnConstItemsParser {
+    const PATH: &[Symbol] = &[sym::lint, sym::should_not_be_called_on_const_items];
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
         Allow(Target::Method(MethodKind::Inherent)),
         Allow(Target::Method(MethodKind::TraitImpl)),
     ]);
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcShouldNotBeCalledOnConstItems;
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::LintShouldNotBeCalledOnConstItems;
 }
 
 pub(crate) struct AutomaticallyDerivedParser;

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -89,22 +89,6 @@ impl SingleAttributeParser for RustcMustImplementOneOfParser {
     }
 }
 
-pub(crate) struct RustcNeverReturnsNullPtrParser;
-
-impl NoArgsAttributeParser for RustcNeverReturnsNullPtrParser {
-    const PATH: &[Symbol] = &[sym::rustc_never_returns_null_ptr];
-    const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
-        Allow(Target::Fn),
-        Allow(Target::Method(MethodKind::Inherent)),
-        Allow(Target::Method(MethodKind::Trait { body: false })),
-        Allow(Target::Method(MethodKind::Trait { body: true })),
-        Allow(Target::Method(MethodKind::TraitImpl)),
-    ]);
-    const STABILITY: AttributeStability = unstable!(rustc_attrs);
-
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcNeverReturnsNullPtr;
-}
-
 pub(crate) struct RustcPanicsWhenZeroParser;
 
 impl NoArgsAttributeParser for RustcPanicsWhenZeroParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -274,6 +274,9 @@ attribute_parsers!(
         Single<WithoutArgs<FfiConstParser>>,
         Single<WithoutArgs<FfiPureParser>>,
         Single<WithoutArgs<FundamentalParser>>,
+        Single<WithoutArgs<LintAsPtrParser>>,
+        Single<WithoutArgs<LintNeverReturnsNullPtrParser>>,
+        Single<WithoutArgs<LintShouldNotBeCalledOnConstItemsParser>>,
         Single<WithoutArgs<LoopMatchParser>>,
         Single<WithoutArgs<MacroEscapeParser>>,
         Single<WithoutArgs<MarkerParser>>,
@@ -299,7 +302,6 @@ attribute_parsers!(
         Single<WithoutArgs<RustcAllocatorZeroedParser>>,
         Single<WithoutArgs<RustcAllowIncoherentImplParser>>,
         Single<WithoutArgs<RustcAllowLifetimeDependentSpecializationParser>>,
-        Single<WithoutArgs<RustcAsPtrParser>>,
         Single<WithoutArgs<RustcCanonicalSymbolParser>>,
         Single<WithoutArgs<RustcCaptureAnalysisParser>>,
         Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
@@ -335,7 +337,6 @@ attribute_parsers!(
         Single<WithoutArgs<RustcLintQueryInstabilityParser>>,
         Single<WithoutArgs<RustcLintUntrackedQueryInformationParser>>,
         Single<WithoutArgs<RustcMainParser>>,
-        Single<WithoutArgs<RustcNeverReturnsNullPtrParser>>,
         Single<WithoutArgs<RustcNoImplicitAutorefsParser>>,
         Single<WithoutArgs<RustcNoImplicitBoundsParser>>,
         Single<WithoutArgs<RustcNoMirInlineParser>>,
@@ -353,7 +354,6 @@ attribute_parsers!(
         Single<WithoutArgs<RustcPubTransparentParser>>,
         Single<WithoutArgs<RustcReallocatorParser>>,
         Single<WithoutArgs<RustcRegionsParser>>,
-        Single<WithoutArgs<RustcShouldNotBeCalledOnConstItemsParser>>,
         Single<WithoutArgs<RustcSpecializationTraitParser>>,
         Single<WithoutArgs<RustcStdInternalSymbolParser>>,
         Single<WithoutArgs<RustcStrictCoherenceParser>>,

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -2196,24 +2196,23 @@ pub(crate) struct MalformedAttribute {
 
 #[derive(Subdiagnostic)]
 pub(crate) enum MalformedAttributeKind {
-    #[label("bad attribute argument")]
-    BadAttributeArgument(#[primary_span] Span),
     #[label("reason in lint attribute must come last")]
     ReasonMustComeLast(#[primary_span] Span),
 }
 
 #[derive(Diagnostic)]
-#[diag("expected a lint, found literal")]
-pub(crate) struct BadAttributeLit {
+#[diag("malformed `{$kind}` attribute input")]
+pub(crate) struct MalformedLintAttributeInput {
     #[primary_span]
     #[label("not the name of a lint")]
     pub span: Span,
+    pub kind: Symbol,
     #[subdiagnostic]
-    pub help: BadAttributeLitHelp,
+    pub help: MalformedLintAttributeInputHelp,
 }
 
 #[derive(Subdiagnostic)]
-pub(crate) enum BadAttributeLitHelp {
+pub(crate) enum MalformedLintAttributeInputHelp {
     #[help("try using `#[{$kind}({$sym})]`")]
     StrLit { sym: Symbol, kind: Symbol },
     #[help("for example, write `#[{$kind}(dead_code)]` for `dead_code`")]
@@ -2248,3 +2247,11 @@ pub(crate) struct DocKeywordAttributeNotAnonConst {
     pub span: Span,
     pub attr_name: Symbol,
 }
+
+#[derive(Diagnostic)]
+#[diag("the `lint::{$unknown}` attribute is not recognized")]
+pub(crate) struct UnknownLintHelper {
+    #[primary_span]
+    pub span: Span,
+    pub unknown: Symbol,
+}

compiler/rustc_attr_parsing/src/interface.rs

@@ -24,7 +24,7 @@ use crate::diagnostics::ParsedDescription;
 use crate::generated::GeneratedAttrState;
 use crate::parser::{AllowExprMetavar, ArgParser, PathParser, RefPathParser};
 use crate::synthetic::SyntheticAttrState;
-use crate::{AttributeTemplate, ShouldEmit};
+use crate::{AttributeTemplate, ShouldEmit, diagnostics};
 
 pub struct EmitAttribute(
     pub  Box<
@@ -446,6 +446,23 @@ impl<'sess> AttributeParser<'sess> {
                         }
                     } else if let [sym::diagnostic, _unknown, ..] = &*parts {
                         self.unknown_diagnostic_attr(&n.item.path.segments[1], &mut emit_lint);
+                    } else if let [sym::lint, unknown, ..] = &*parts {
+                        // Avoid cascading errors. If the `lint` tool has not been registered,
+                        // we could be here in the `#[lint::attribute_macro] not found` case,
+                        // which recovers with a `NonMacroAttr` res.
+                        if let Some(tools) = self.attr_tools
+                            && tools.iter().any(|i| i.name == sym::lint)
+                        {
+                            self.emit_err(diagnostics::UnknownLintHelper {
+                                span: n.item.span,
+                                unknown: *unknown,
+                            });
+                        } else {
+                            self.dcx().span_delayed_bug(
+                                n.item.span,
+                                "encountered `lint` tool attribute but error not reported",
+                            );
+                        }
                     } else {
                         let attr = AttrItem {
                             path: attr_path.clone(),