Rename the attribute to on_unknown

Author: weiznich

compiler/rustc_attr_parsing/src/attributes/diagnostic/mod.rs

@@ -24,7 +24,7 @@ pub(crate) mod do_not_recommend;
 pub(crate) mod on_const;
 pub(crate) mod on_move;
 pub(crate) mod on_unimplemented;
-pub(crate) mod on_unknown_item;
+pub(crate) mod on_unknown;
 
 #[derive(Copy, Clone)]
 pub(crate) enum Mode {
@@ -36,8 +36,8 @@ pub(crate) enum Mode {
     DiagnosticOnConst,
     /// `#[diagnostic::on_move]`
     DiagnosticOnMove,
-    /// `#[diagnostic::on_unknown_item]`
-    DiagnosticOnUnknownItem,
+    /// `#[diagnostic::on_unknown]`
+    DiagnosticOnUnknown,
 }
 
 fn merge_directives<S: Stage>(
@@ -125,10 +125,10 @@ fn parse_directive_items<'p, S: Stage>(
                         span,
                     );
                 }
-                Mode::DiagnosticOnUnknownItem => {
+                Mode::DiagnosticOnUnknown => {
                     cx.emit_lint(
                         MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                        AttributeLintKind::MalformedOnUnknownItemdAttr { span },
+                        AttributeLintKind::MalformedOnUnknownAttr { span },
                         span,
                     );
                 }
@@ -150,7 +150,7 @@ fn parse_directive_items<'p, S: Stage>(
                 Mode::RustcOnUnimplemented => {
                     cx.emit_err(NoValueInOnUnimplemented { span: item.span() });
                 }
-                Mode::DiagnosticOnUnimplemented |Mode::DiagnosticOnConst | Mode::DiagnosticOnMove | Mode::DiagnosticOnUnknownItem => {
+                Mode::DiagnosticOnUnimplemented |Mode::DiagnosticOnConst | Mode::DiagnosticOnMove | Mode::DiagnosticOnUnknown => {
                     cx.emit_lint(
                         MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                         AttributeLintKind::IgnoredDiagnosticOption {
@@ -337,7 +337,7 @@ fn parse_arg(
     is_source_literal: bool,
 ) -> FormatArg {
     let span = slice_span(input_span, arg.position_span.clone(), is_source_literal);
-    if matches!(mode, Mode::DiagnosticOnUnknownItem) {
+    if matches!(mode, Mode::DiagnosticOnUnknown) {
         warnings.push(FormatWarning::DisallowedPlaceholder { span });
         return FormatArg::AsIs(sym::empty_braces);
     }

…attributes/diagnostic/on_unknown_item.rs …/src/attributes/diagnostic/on_unknown.rscompiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown_item.rs renamed to compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown_item.rs renamed to compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs

@@ -5,19 +5,19 @@ use crate::attributes::diagnostic::*;
 use crate::attributes::prelude::*;
 
 #[derive(Default)]
-pub(crate) struct OnUnknownItemParser {
+pub(crate) struct OnUnknownParser {
     span: Option<Span>,
     directive: Option<(Span, Directive)>,
 }
 
-impl OnUnknownItemParser {
+impl OnUnknownParser {
     fn parse<'sess, S: Stage>(
         &mut self,
         cx: &mut AcceptContext<'_, 'sess, S>,
         args: &ArgParser,
         mode: Mode,
     ) {
-        if !cx.features().diagnostic_on_unknown_item() {
+        if !cx.features().diagnostic_on_unknown() {
             return;
         }
         let span = cx.attr_span;
@@ -28,15 +28,15 @@ impl OnUnknownItemParser {
             ArgParser::NoArgs | ArgParser::List(_) => {
                 cx.emit_lint(
                     MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                    AttributeLintKind::MissingOptionsForOnUnknownItem,
+                    AttributeLintKind::MissingOptionsForOnUnknown,
                     span,
                 );
                 return;
             }
             ArgParser::NameValue(_) => {
                 cx.emit_lint(
                     MALFORMED_DIAGNOSTIC_ATTRIBUTES,
-                    AttributeLintKind::MalformedOnUnknownItemdAttr { span },
+                    AttributeLintKind::MalformedOnUnknownAttr { span },
                     span,
                 );
                 return;
@@ -49,20 +49,20 @@ impl OnUnknownItemParser {
     }
 }
 
-impl<S: Stage> AttributeParser<S> for OnUnknownItemParser {
+impl<S: Stage> AttributeParser<S> for OnUnknownParser {
     const ATTRIBUTES: AcceptMapping<Self, S> = &[(
-        &[sym::diagnostic, sym::on_unknown_item],
+        &[sym::diagnostic, sym::on_unknown],
         template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
         |this, cx, args| {
-            this.parse(cx, args, Mode::DiagnosticOnUnknownItem);
+            this.parse(cx, args, Mode::DiagnosticOnUnknown);
         },
     )];
     //FIXME attribute is not parsed for non-use statements but diagnostics are issued in `check_attr.rs`
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         if let Some(span) = self.span {
-            Some(AttributeKind::OnUnknownItem {
+            Some(AttributeKind::OnUnknown {
                 span,
                 directive: self.directive.map(|d| Box::new(d.1)),
             })

compiler/rustc_attr_parsing/src/context.rs

@@ -32,7 +32,7 @@ use crate::attributes::diagnostic::do_not_recommend::*;
 use crate::attributes::diagnostic::on_const::*;
 use crate::attributes::diagnostic::on_move::*;
 use crate::attributes::diagnostic::on_unimplemented::*;
-use crate::attributes::diagnostic::on_unknown_item::*;
+use crate::attributes::diagnostic::on_unknown::*;
 use crate::attributes::doc::*;
 use crate::attributes::dummy::*;
 use crate::attributes::inline::*;
@@ -155,7 +155,7 @@ attribute_parsers!(
         OnConstParser,
         OnMoveParser,
         OnUnimplementedParser,
-        OnUnknownItemParser,
+        OnUnknownParser,
         RustcAlignParser,
         RustcAlignStaticParser,
         RustcCguTestAttributeParser,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1588,7 +1588,7 @@ pub fn is_stable_diagnostic_attribute(sym: Symbol, features: &Features) -> bool
         sym::on_unimplemented | sym::do_not_recommend => true,
         sym::on_const => features.diagnostic_on_const(),
         sym::on_move => features.diagnostic_on_move(),
-        sym::on_unknown_item => features.diagnostic_on_unknown_item(),
+        sym::on_unknown => features.diagnostic_on_unknown(),
         _ => false,
     }
 }

compiler/rustc_feature/src/unstable.rs

@@ -475,7 +475,7 @@ declare_features! (
     /// Allows giving on-move borrowck custom diagnostic messages for a type
     (unstable, diagnostic_on_move, "CURRENT_RUSTC_VERSION", Some(154181)),
     /// Allows giving unresolved imports a custom diagnostic message
-    (unstable, diagnostic_on_unknown_item, "CURRENT_RUSTC_VERSION", Some(152900)),
+    (unstable, diagnostic_on_unknown, "CURRENT_RUSTC_VERSION", Some(152900)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
     /// Allows `#[doc(masked)]`.

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1193,8 +1193,8 @@ pub enum AttributeKind {
         directive: Option<Box<Directive>>,
     },
 
-    /// Represents `#[diagnostic::on_unknown_item]`
-    OnUnknownItem {
+    /// Represents `#[diagnostic::on_unknown]`
+    OnUnknown {
         span: Span,
         /// None if the directive was malformed in some way.
         directive: Option<Box<Directive>>,

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -79,7 +79,7 @@ impl AttributeKind {
             OnConst { .. } => Yes,
             OnMove { .. } => Yes,
             OnUnimplemented { .. } => Yes,
-            OnUnknownItem { .. } => Yes,
+            OnUnknown { .. } => Yes,
             Optimize(..) => No,
             PanicRuntime => No,
             PatchableFunctionEntry { .. } => Yes,

compiler/rustc_lint/src/early/diagnostics.rs

@@ -179,8 +179,8 @@ impl<'a> Diagnostic<'a, ()> for DecorateAttrLint<'_, '_, '_> {
             &AttributeLintKind::MalformedOnUnimplementedAttr { span } => {
                 lints::MalformedOnUnimplementedAttrLint { span }.into_diag(dcx, level)
             }
-            &AttributeLintKind::MalformedOnUnknownItemdAttr { span } => {
-                lints::MalformedOnUnknownItemAttrLint { span }.into_diag(dcx, level)
+            &AttributeLintKind::MalformedOnUnknownAttr { span } => {
+                lints::MalformedOnUnknownAttrLint { span }.into_diag(dcx, level)
             }
             &AttributeLintKind::MalformedOnConstAttr { span } => {
                 lints::MalformedOnConstAttrLint { span }.into_diag(dcx, level)
@@ -221,8 +221,8 @@ impl<'a> Diagnostic<'a, ()> for DecorateAttrLint<'_, '_, '_> {
             &AttributeLintKind::MissingOptionsForOnMove => {
                 lints::MissingOptionsForOnMoveAttr.into_diag(dcx, level)
             }
-            &AttributeLintKind::MissingOptionsForOnUnknownItem => {
-                lints::MissingOptionsForOnUnknownItemAttr.into_diag(dcx, level)
+            &AttributeLintKind::MissingOptionsForOnUnknown => {
+                lints::MissingOptionsForOnUnknownAttr.into_diag(dcx, level)
             }
         }
     }

compiler/rustc_lint/src/lints.rs

@@ -3577,9 +3577,9 @@ pub(crate) struct IgnoredDiagnosticOption {
 pub(crate) struct MissingOptionsForOnUnimplementedAttr;
 
 #[derive(Diagnostic)]
-#[diag("missing options for `on_unknown_item` attribute")]
+#[diag("missing options for `on_unknown` attribute")]
 #[help("at least one of the `message`, `note` and `label` options are expected")]
-pub(crate) struct MissingOptionsForOnUnknownItemAttr;
+pub(crate) struct MissingOptionsForOnUnknownAttr;
 
 #[derive(Diagnostic)]
 #[diag("missing options for `on_const` attribute")]
@@ -3600,9 +3600,9 @@ pub(crate) struct MalformedOnUnimplementedAttrLint {
 }
 
 #[derive(Diagnostic)]
-#[diag("malformed `on_unknown_item` attribute")]
+#[diag("malformed `on_unknown` attribute")]
 #[help("only `message`, `note` and `label` are allowed as options")]
-pub(crate) struct MalformedOnUnknownItemAttrLint {
+pub(crate) struct MalformedOnUnknownAttrLint {
     #[label("invalid option found here")]
     pub span: Span,
 }

compiler/rustc_lint_defs/src/lib.rs

@@ -736,7 +736,7 @@ pub enum AttributeLintKind {
     MalformedOnUnimplementedAttr {
         span: Span,
     },
-    MalformedOnUnknownItemdAttr {
+    MalformedOnUnknownAttr {
         span: Span,
     },
     MalformedOnConstAttr {
@@ -760,7 +760,7 @@ pub enum AttributeLintKind {
     },
     MissingOptionsForOnUnimplemented,
     MissingOptionsForOnConst,
-    MissingOptionsForOnUnknownItem,
+    MissingOptionsForOnUnknown,
     MissingOptionsForOnMove,
     OnMoveMalformedFormatLiterals {
         name: Symbol,