Port #[register_tool] to the new attribute system

Cargo.lock

@@ -3415,6 +3415,7 @@ dependencies = [
  "rustc_errors",
  "rustc_feature",
  "rustc_fluent_macro",
+ "rustc_hir",
  "rustc_macros",
  "rustc_session",
  "rustc_span",

compiler/rustc_ast_passes/Cargo.toml

@@ -14,6 +14,7 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
+rustc_hir = { path = "../rustc_hir" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,11 +1,14 @@
 use rustc_ast as ast;
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
 use rustc_ast::{NodeId, PatKind, attr, token};
+use rustc_attr_parsing::AttributeParser;
 use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features};
+use rustc_hir::Attribute;
+use rustc_hir::attrs::AttributeKind;
 use rustc_session::Session;
 use rustc_session::parse::{feature_err, feature_warn};
 use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 use thin_vec::ThinVec;
 
 use crate::errors;
@@ -587,17 +590,27 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
         return;
     }
     let mut errored = false;
-    for attr in krate.attrs.iter().filter(|attr| attr.has_name(sym::feature)) {
+
+    if let Some(Attribute::Parsed(AttributeKind::Feature(feature_idents, first_span))) =
+        AttributeParser::parse_limited(
+            sess,
+            &krate.attrs,
+            sym::feature,
+            DUMMY_SP,
+            krate.id,
+            Some(&features),
+        )
+    {
         // `feature(...)` used on non-nightly. This is definitely an error.
         let mut err = errors::FeatureOnNonNightly {
-            span: attr.span,
+            span: first_span,
             channel: option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)"),
             stable_features: vec![],
             sugg: None,
         };
 
         let mut all_stable = true;
-        for ident in attr.meta_item_list().into_iter().flatten().flat_map(|nested| nested.ident()) {
+        for ident in feature_idents {
             let name = ident.name;
             let stable_since = features
                 .enabled_lang_features()
@@ -612,7 +625,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
             }
         }
         if all_stable {
-            err.sugg = Some(attr.span);
+            err.sugg = Some(first_span);
         }
         sess.dcx().emit_err(err);
         errored = true;

compiler/rustc_attr_parsing/messages.ftl

@@ -259,3 +259,7 @@ attr_parsing_whole_archive_needs_static =
 attr_parsing_limit_invalid =
     `limit` must be a non-negative integer
     .label = {$error_str}
+
+attr_parsing_single_word =
+    {$description} are always a single identifier, not paths with multiple segments
+    .help = did you maybe mean `{$first_segment}`?

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -1,4 +1,5 @@
 use super::prelude::*;
+use crate::session_diagnostics::{ExpectedSingleWord, LimitInvalid};
 
 pub(crate) struct CrateNameParser;
 
@@ -147,3 +148,112 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcCoherenceIsCoreParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcCoherenceIsCore;
 }
+
+pub(crate) struct FeatureParser;
+
+impl<S: Stage> CombineAttributeParser<S> for FeatureParser {
+    const PATH: &[Symbol] = &[sym::feature];
+    type Item = Ident;
+    const CONVERT: ConvertFn<Self::Item> = AttributeKind::Feature;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::CrateLevel;
+    const TEMPLATE: AttributeTemplate = template!(List: &["feature1, feature2, ..."]);
+
+    fn extend<'c>(
+        cx: &'c mut AcceptContext<'_, '_, S>,
+        args: &'c ArgParser<'_>,
+    ) -> impl IntoIterator<Item = Self::Item> + 'c {
+        let ArgParser::List(list) = args else {
+            cx.expected_list(cx.attr_span);
+            return Vec::new();
+        };
+
+        if list.is_empty() {
+            cx.warn_empty_attribute(cx.attr_span);
+        }
+
+        let mut res = Vec::new();
+
+        for elem in list.mixed() {
+            let Some(elem) = elem.meta_item() else {
+                cx.expected_identifier(elem.span());
+                continue;
+            };
+            if let Err(arg_span) = elem.args().no_args() {
+                cx.expected_no_args(arg_span);
+                continue;
+            }
+
+            let path = elem.path();
+            let Some(ident) = path.word() else {
+                let first_segment = elem.path().segments().next().expect("at least one segment");
+                cx.emit_err(ExpectedSingleWord {
+                    description: "rust features",
+                    span: path.span(),
+                    first_segment_span: first_segment.span,
+                    first_segment: first_segment.name,
+                });
+                continue;
+            };
+
+            res.push(ident);
+        }
+
+        res
+    }
+}
+
+pub(crate) struct RegisterToolParser;
+
+impl<S: Stage> CombineAttributeParser<S> for RegisterToolParser {
+    const PATH: &[Symbol] = &[sym::register_tool];
+    type Item = Ident;
+    const CONVERT: ConvertFn<Self::Item> = AttributeKind::RegisterTool;
+
+    // FIXME: recursion limit is allowed on all targets and ignored,
+    //        even though it should only be valid on crates of course
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+    const TEMPLATE: AttributeTemplate = template!(List: &["tool1, tool2, ..."]);
+
+    fn extend<'c>(
+        cx: &'c mut AcceptContext<'_, '_, S>,
+        args: &'c ArgParser<'_>,
+    ) -> impl IntoIterator<Item = Self::Item> + 'c {
+        let ArgParser::List(list) = args else {
+            cx.expected_list(cx.attr_span);
+            return Vec::new();
+        };
+
+        if list.is_empty() {
+            cx.warn_empty_attribute(cx.attr_span);
+        }
+
+        let mut res = Vec::new();
+
+        for elem in list.mixed() {
+            let Some(elem) = elem.meta_item() else {
+                cx.expected_identifier(elem.span());
+                continue;
+            };
+            if let Err(arg_span) = elem.args().no_args() {
+                cx.expected_no_args(arg_span);
+                continue;
+            }
+
+            let path = elem.path();
+            let Some(ident) = path.word() else {
+                let first_segment = elem.path().segments().next().expect("at least one segment");
+                cx.emit_err(ExpectedSingleWord {
+                    description: "tools",
+                    span: path.span(),
+                    first_segment_span: first_segment.span,
+                    first_segment: first_segment.name,
+                });
+                continue;
+            };
+
+            res.push(ident);
+        }
+
+        res
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -25,8 +25,9 @@ use crate::attributes::codegen_attrs::{
 };
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
-    CrateNameParser, MoveSizeLimitParser, NoCoreParser, NoStdParser, PatternComplexityLimitParser,
-    RecursionLimitParser, RustcCoherenceIsCoreParser, TypeLengthLimitParser,
+    CrateNameParser, FeatureParser, MoveSizeLimitParser, NoCoreParser, NoStdParser,
+    PatternComplexityLimitParser, RecursionLimitParser, RegisterToolParser,
+    RustcCoherenceIsCoreParser, TypeLengthLimitParser,
 };
 use crate::attributes::debugger::DebuggerViualizerParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -165,8 +166,10 @@ attribute_parsers!(
         Combine<AllowConstFnUnstableParser>,
         Combine<AllowInternalUnstableParser>,
         Combine<DebuggerViualizerParser>,
+        Combine<FeatureParser>,
         Combine<ForceTargetFeatureParser>,
         Combine<LinkParser>,
+        Combine<RegisterToolParser>,
         Combine<ReprParser>,
         Combine<TargetFeatureParser>,
         Combine<UnstableFeatureBoundParser>,

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -968,3 +968,16 @@ pub(crate) struct LimitInvalid<'a> {
     pub value_span: Span,
     pub error_str: &'a str,
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_single_word)]
+pub(crate) struct ExpectedSingleWord {
+    pub description: &'static str,
+
+    #[primary_span]
+    pub span: Span,
+
+    #[help]
+    pub first_segment_span: Span,
+    pub first_segment: Symbol,
+}

compiler/rustc_driver_impl/src/lib.rs

@@ -709,8 +709,9 @@ fn print_crate_info(
                 };
                 let crate_name = passes::get_crate_name(sess, attrs);
                 let lint_store = crate::unerased_lint_store(sess);
-                let registered_tools = rustc_resolve::registered_tools_ast(sess.dcx(), attrs);
                 let features = rustc_expand::config::features(sess, attrs, crate_name);
+                let registered_tools =
+                    rustc_resolve::registered_tools_ast(sess.dcx(), attrs, sess, &features);
                 let lint_levels = rustc_lint::LintLevelsBuilder::crate_root(
                     sess,
                     &features,

compiler/rustc_error_codes/src/error_codes/E0556.md

@@ -1,8 +1,10 @@
+#### Note: this error code is no longer emitted by the compiler.
+
 The `feature` attribute was badly formed.
 
 Erroneous code example:
 
-```compile_fail,E0556
+```compile_fail
 #![feature(foo_bar_baz, foo(bar), foo = "baz", foo)] // error!
 #![feature] // error!
 #![feature = "foo"] // error!

compiler/rustc_error_codes/src/lib.rs

@@ -338,7 +338,7 @@ E0550: 0550,
 E0551: 0551,
 E0552: 0552,
 E0554: 0554,
-E0556: 0556,
+E0556: 0556, // REMOVED: merged with other attribute error codes
 E0557: 0557,
 E0559: 0559,
 E0560: 0560,