Lazily check diagnostic namespace features

Author: mejrs

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

@@ -17,6 +17,7 @@ impl<S: Stage> AttributeParser<S> for OnConstParser {
         template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
         |this, cx, args| {
             if !cx.features().diagnostic_on_const() {
+                // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
                 return;
             }
 

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

@@ -18,6 +18,7 @@ impl OnUnknownParser {
         mode: Mode,
     ) {
         if !cx.features().diagnostic_on_unknown() {
+            // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
             return;
         }
         let span = cx.attr_span;

compiler/rustc_resolve/src/macros.rs

@@ -712,25 +712,28 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             feature_err(&self.tcx.sess, sym::custom_inner_attributes, path.span, msg).emit();
         }
 
-        let diagnostic_attributes: &[(Symbol, bool)] = &[
-            (sym::on_unimplemented, true),
-            (sym::do_not_recommend, true),
-            (sym::on_move, true),
-            (sym::on_const, self.tcx.features().diagnostic_on_const()),
-            (sym::on_unknown, self.tcx.features().diagnostic_on_unknown()),
+        const DIAGNOSTIC_ATTRIBUTES: &[(Symbol, Option<Symbol>)] = &[
+            (sym::on_unimplemented, None),
+            (sym::do_not_recommend, None),
+            (sym::on_move, None),
+            (sym::on_const, Some(sym::diagnostic_on_const)),
+            (sym::on_unknown, Some(sym::diagnostic_on_unknown)),
         ];
 
         if res == Res::NonMacroAttr(NonMacroAttrKind::Tool)
             && let [namespace, attribute, ..] = &*path.segments
             && namespace.ident.name == sym::diagnostic
-            && !diagnostic_attributes
-                .iter()
-                .any(|(attr, stable)| *stable && attribute.ident.name == *attr)
+            && !DIAGNOSTIC_ATTRIBUTES.iter().any(|(attr, stable)| {
+                attribute.ident.name == *attr
+                    && stable.is_none_or(|f| self.tcx.features().enabled(f))
+            })
         {
             let span = attribute.span();
-            let candidates = diagnostic_attributes
+            let candidates = DIAGNOSTIC_ATTRIBUTES
                 .iter()
-                .filter_map(|(sym, stable)| stable.then_some(*sym))
+                .filter_map(|(sym, stable)| {
+                    stable.is_none_or(|f| self.tcx.features().enabled(f)).then_some(*sym)
+                })
                 .collect::<Vec<_>>();
             let typo = find_best_match_for_name(&candidates, attribute.ident.name, Some(5))
                 .map(|typo_name| errors::UnknownDiagnosticAttributeTypoSugg { span, typo_name });