Rollup of 10 pull requests

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -649,7 +649,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
         AttributeParser::parse_limited(
             sess,
             &krate.attrs,
-            sym::feature,
+            &[sym::feature],
             DUMMY_SP,
             krate.id,
             Some(&features),

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

@@ -24,6 +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;
 
 #[derive(Copy, Clone)]
 pub(crate) enum Mode {
@@ -35,6 +36,8 @@ pub(crate) enum Mode {
     DiagnosticOnConst,
     /// `#[diagnostic::on_move]`
     DiagnosticOnMove,
+    /// `#[diagnostic::on_unknown]`
+    DiagnosticOnUnknown,
 }
 
 fn merge_directives<S: Stage>(
@@ -122,6 +125,13 @@ fn parse_directive_items<'p, S: Stage>(
                         span,
                     );
                 }
+                Mode::DiagnosticOnUnknown => {
+                    cx.emit_lint(
+                        MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                        AttributeLintKind::MalformedOnUnknownAttr { span },
+                        span,
+                    );
+                }
             }
             continue;
         }}
@@ -140,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::DiagnosticOnUnimplemented |Mode::DiagnosticOnConst | Mode::DiagnosticOnMove | Mode::DiagnosticOnUnknown => {
                     cx.emit_lint(
                         MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                         AttributeLintKind::IgnoredDiagnosticOption {
@@ -176,7 +186,8 @@ fn parse_directive_items<'p, S: Stage>(
                 Ok((f, warnings)) => {
                     for warning in warnings {
                         let (FormatWarning::InvalidSpecifier { span, .. }
-                        | FormatWarning::PositionalArgument { span, .. }) = warning;
+                        | FormatWarning::PositionalArgument { span, .. }
+                        | FormatWarning::DisallowedPlaceholder { span }) = warning;
                         cx.emit_lint(
                             MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
                             AttributeLintKind::MalformedDiagnosticFormat { warning },
@@ -326,6 +337,10 @@ 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::DiagnosticOnUnknown) {
+        warnings.push(FormatWarning::DisallowedPlaceholder { span });
+        return FormatArg::AsIs(sym::empty_braces);
+    }
 
     match arg.position {
         // Something like "hello {name}"

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

@@ -0,0 +1,73 @@
+use rustc_hir::attrs::diagnostic::Directive;
+use rustc_session::lint::builtin::MALFORMED_DIAGNOSTIC_ATTRIBUTES;
+
+use crate::attributes::diagnostic::*;
+use crate::attributes::prelude::*;
+
+#[derive(Default)]
+pub(crate) struct OnUnknownParser {
+    span: Option<Span>,
+    directive: Option<(Span, Directive)>,
+}
+
+impl OnUnknownParser {
+    fn parse<'sess, S: Stage>(
+        &mut self,
+        cx: &mut AcceptContext<'_, 'sess, S>,
+        args: &ArgParser,
+        mode: Mode,
+    ) {
+        if !cx.features().diagnostic_on_unknown() {
+            return;
+        }
+        let span = cx.attr_span;
+        self.span = Some(span);
+
+        let items = match args {
+            ArgParser::List(items) if !items.is_empty() => items,
+            ArgParser::NoArgs | ArgParser::List(_) => {
+                cx.emit_lint(
+                    MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                    AttributeLintKind::MissingOptionsForOnUnknown,
+                    span,
+                );
+                return;
+            }
+            ArgParser::NameValue(_) => {
+                cx.emit_lint(
+                    MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+                    AttributeLintKind::MalformedOnUnknownAttr { span },
+                    span,
+                );
+                return;
+            }
+        };
+
+        if let Some(directive) = parse_directive_items(cx, mode, items.mixed(), true) {
+            merge_directives(cx, &mut self.directive, (span, directive));
+        };
+    }
+}
+
+impl<S: Stage> AttributeParser<S> for OnUnknownParser {
+    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
+        &[sym::diagnostic, sym::on_unknown],
+        template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
+        |this, cx, args| {
+            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::OnUnknown {
+                span,
+                directive: self.directive.map(|d| Box::new(d.1)),
+            })
+        } else {
+            None
+        }
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -32,6 +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::*;
 use crate::attributes::doc::*;
 use crate::attributes::dummy::*;
 use crate::attributes::inline::*;
@@ -156,6 +157,7 @@ attribute_parsers!(
         OnConstParser,
         OnMoveParser,
         OnUnimplementedParser,
+        OnUnknownParser,
         RustcAlignParser,
         RustcAlignStaticParser,
         RustcCguTestAttributeParser,

compiler/rustc_attr_parsing/src/interface.rs

@@ -30,7 +30,7 @@ pub struct AttributeParser<'sess, S: Stage = Late> {
     /// *Only* parse attributes with this symbol.
     ///
     /// Used in cases where we want the lowering infrastructure for parse just a single attribute.
-    parse_only: Option<Symbol>,
+    parse_only: Option<&'static [Symbol]>,
 }
 
 impl<'sess> AttributeParser<'sess, Early> {
@@ -53,7 +53,7 @@ impl<'sess> AttributeParser<'sess, Early> {
     pub fn parse_limited(
         sess: &'sess Session,
         attrs: &[ast::Attribute],
-        sym: Symbol,
+        sym: &'static [Symbol],
         target_span: Span,
         target_node_id: NodeId,
         features: Option<&'sess Features>,
@@ -77,7 +77,7 @@ impl<'sess> AttributeParser<'sess, Early> {
     pub fn parse_limited_should_emit(
         sess: &'sess Session,
         attrs: &[ast::Attribute],
-        sym: Symbol,
+        sym: &'static [Symbol],
         target_span: Span,
         target_node_id: NodeId,
         target: Target,
@@ -109,7 +109,7 @@ impl<'sess> AttributeParser<'sess, Early> {
     pub fn parse_limited_all<'a>(
         sess: &'sess Session,
         attrs: impl IntoIterator<Item = &'a ast::Attribute>,
-        parse_only: Option<Symbol>,
+        parse_only: Option<&'static [Symbol]>,
         target: Target,
         target_span: Span,
         target_node_id: NodeId,
@@ -301,7 +301,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         for attr in attrs.into_iter() {
             // If we're only looking for a single attribute, skip all the ones we don't care about.
             if let Some(expected) = self.parse_only {
-                if !attr.has_name(expected) {
+                if !attr.path_matches(expected) {
                     continue;
                 }
             }

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -493,7 +493,7 @@ impl<'a> TraitDef<'a> {
         match item {
             Annotatable::Item(item) => {
                 let is_packed = matches!(
-                    AttributeParser::parse_limited(cx.sess, &item.attrs, sym::repr, item.span, item.id, None),
+                    AttributeParser::parse_limited(cx.sess, &item.attrs, &[sym::repr], item.span, item.id, None),
                     Some(Attribute::Parsed(AttributeKind::Repr { reprs, .. })) if reprs.iter().any(|(x, _)| matches!(x, ReprPacked(..)))
                 );
 

compiler/rustc_builtin_macros/src/proc_macro_harness.rs

@@ -108,7 +108,7 @@ impl<'a> CollectProcMacros<'a> {
         })) = AttributeParser::parse_limited(
             self.session,
             slice::from_ref(attr),
-            sym::proc_macro_derive,
+            &[sym::proc_macro_derive],
             item.span,
             item.node_id(),
             None,

compiler/rustc_builtin_macros/src/test.rs

@@ -483,7 +483,7 @@ fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
         AttributeParser::parse_limited(
             cx.sess,
             &i.attrs,
-            sym::should_panic,
+            &[sym::should_panic],
             i.span,
             i.node_id(),
             None,

compiler/rustc_builtin_macros/src/test_harness.rs

@@ -391,7 +391,7 @@ fn get_test_runner(sess: &Session, features: &Features, krate: &ast::Crate) -> O
     match AttributeParser::parse_limited(
         sess,
         &krate.attrs,
-        sym::test_runner,
+        &[sym::test_runner],
         krate.spans.inner_span,
         krate.id,
         Some(features),

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -630,6 +630,7 @@ fn llvm_features_by_flags(sess: &Session, features: &mut Vec<String>) {
     }
 
     target_features::retpoline_features_by_flags(sess, features);
+    target_features::sanitizer_features_by_flags(sess, features);
 
     // -Zfixed-x18
     if sess.opts.unstable_opts.fixed_x18 {

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -10,7 +10,7 @@ use rustc_session::Session;
 use rustc_session::lint::builtin::AARCH64_SOFTFLOAT_NEON;
 use rustc_session::parse::feature_err;
 use rustc_span::{Span, Symbol, edit_distance, sym};
-use rustc_target::spec::Arch;
+use rustc_target::spec::{Arch, SanitizerSet};
 use rustc_target::target_features::{RUSTC_SPECIFIC_FEATURES, Stability};
 use smallvec::SmallVec;
 
@@ -460,6 +460,15 @@ pub fn retpoline_features_by_flags(sess: &Session, features: &mut Vec<String>) {
     }
 }
 
+/// Computes the backend target features to be added to account for sanitizer flags.
+pub fn sanitizer_features_by_flags(sess: &Session, features: &mut Vec<String>) {
+    // It's intentional that this is done only for non-kernel version of hwaddress. This matches
+    // clang behavior.
+    if sess.sanitizers().contains(SanitizerSet::HWADDRESS) {
+        features.push("+tagged-globals".into());
+    }
+}
+
 pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers {
         rust_target_features: |tcx, cnum| {

compiler/rustc_expand/src/config.rs

@@ -54,7 +54,7 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
         AttributeParser::parse_limited(
             sess,
             krate_attrs,
-            sym::feature,
+            &[sym::feature],
             DUMMY_SP,
             DUMMY_NODE_ID,
             Some(&features),

compiler/rustc_feature/src/builtin_attrs.rs

@@ -814,6 +814,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 => features.diagnostic_on_unknown(),
         _ => false,
     }
 }

compiler/rustc_feature/src/unstable.rs

@@ -474,6 +474,8 @@ declare_features! (
     (unstable, diagnostic_on_const, "1.93.0", Some(143874)),
     /// 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, "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

@@ -1334,6 +1334,14 @@ pub enum AttributeKind {
         /// None if the directive was malformed in some way.
         directive: Option<Box<Directive>>,
     },
+
+    /// Represents `#[diagnostic::on_unknown]`
+    OnUnknown {
+        span: Span,
+        /// None if the directive was malformed in some way.
+        directive: Option<Box<Directive>>,
+    },
+
     /// Represents `#[optimize(size|speed)]`
     Optimize(OptimizeAttr, Span),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

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