port #[register_tool] to the new attribute parsing infrastructure

jdonszelmann · jdonszelmann · commit f73a0b5f566f · 2025-09-17T23:01:19.000-07:00
diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
@@ -260,6 +260,6 @@ attr_parsing_limit_invalid =
     `limit` must be a non-negative integer
     .label = {$error_str}
 
-attr_parsing_feature_single_word =
-    rust features are always a single identifier, not paths with multiple segments
+attr_parsing_single_word =
+    {$description} are always a single identifier, not paths with multiple segments
     .help = did you maybe mean `{$first_segment}`?
diff --git a/compiler/rustc_attr_parsing/src/attributes/crate_level.rs b/compiler/rustc_attr_parsing/src/attributes/crate_level.rs
@@ -3,7 +3,7 @@ use std::num::IntErrorKind;
 use rustc_hir::limit::Limit;
 
 use super::prelude::*;
-use crate::session_diagnostics::{FeatureExpectedSingleWord, LimitInvalid};
+use crate::session_diagnostics::{ExpectedSingleWord, LimitInvalid};
 
 impl<S: Stage> AcceptContext<'_, '_, S> {
     fn parse_limit_int(&self, nv: &NameValueParser) -> Option<Limit> {
@@ -221,7 +221,64 @@ impl<S: Stage> CombineAttributeParser<S> for FeatureParser {
             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(FeatureExpectedSingleWord {
+                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,
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
@@ -26,8 +26,8 @@ use crate::attributes::codegen_attrs::{
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::crate_level::{
     CrateNameParser, FeatureParser, MoveSizeLimitParser, NoCoreParser, NoStdParser,
-    PatternComplexityLimitParser, RecursionLimitParser, RustcCoherenceIsCoreParser,
-    TypeLengthLimitParser,
+    PatternComplexityLimitParser, RecursionLimitParser, RegisterToolParser,
+    RustcCoherenceIsCoreParser, TypeLengthLimitParser,
 };
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::dummy::DummyParser;
@@ -167,6 +167,7 @@ attribute_parsers!(
         Combine<FeatureParser>,
         Combine<ForceTargetFeatureParser>,
         Combine<LinkParser>,
+        Combine<RegisterToolParser>,
         Combine<ReprParser>,
         Combine<TargetFeatureParser>,
         Combine<UnstableFeatureBoundParser>,
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -970,8 +970,10 @@ pub(crate) struct LimitInvalid<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(attr_parsing_feature_single_word)]
-pub(crate) struct FeatureExpectedSingleWord {
+#[diag(attr_parsing_single_word)]
+pub(crate) struct ExpectedSingleWord {
+    pub description: &'static str,
+
     #[primary_span]
     pub span: Span,
 
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
@@ -710,8 +710,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,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -633,6 +633,9 @@ pub enum AttributeKind {
     /// Represents [`#[recursion_limit]`](https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute)
     RecursionLimit { attr_span: Span, limit_span: Span, limit: Limit },
 
+    /// Represents `#[register_tool]`
+    RegisterTool(ThinVec<Ident>, Span),
+
     /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
     Repr { reprs: ThinVec<(ReprAttr, Span)>, first_span: Span },
 
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -82,6 +82,7 @@ impl AttributeKind {
             ProcMacroDerive { .. } => No,
             PubTransparent(..) => Yes,
             RecursionLimit { .. } => No,
+            RegisterTool(..) => No,
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcCoherenceIsCore(..) => No,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -279,6 +279,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::ObjcSelector { .. }
                     | AttributeKind::RustcCoherenceIsCore(..)
                     | AttributeKind::Feature(..)
+                    | AttributeKind::RegisterTool(..)
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
@@ -415,10 +415,6 @@ resolve_tool_module_imported =
     cannot use a tool module through an import
     .note = the tool module imported here
 
-resolve_tool_only_accepts_identifiers =
-    `{$tool}` only accepts identifiers
-    .label = not an identifier
-
 resolve_tool_was_already_registered =
     tool `{$tool}` was already registered
     .label = already registered here
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
@@ -1120,15 +1120,6 @@ pub(crate) struct ToolWasAlreadyRegistered {
     pub(crate) old_ident_span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(resolve_tool_only_accepts_identifiers)]
-pub(crate) struct ToolOnlyAcceptsIdentifiers {
-    #[primary_span]
-    #[label]
-    pub(crate) span: Span,
-    pub(crate) tool: Symbol,
-}
-
 #[derive(Subdiagnostic)]
 pub(crate) enum DefinedHere {
     #[label(resolve_similarly_named_defined_here)]
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
@@ -5,8 +5,9 @@ use std::cell::Cell;
 use std::mem;
 use std::sync::Arc;
 
-use rustc_ast::{self as ast, Crate, NodeId, attr};
+use rustc_ast::{self as ast, Crate, DUMMY_NODE_ID, NodeId};
 use rustc_ast_pretty::pprust;
+use rustc_attr_parsing::AttributeParser;
 use rustc_errors::{Applicability, DiagCtxtHandle, StashKey};
 use rustc_expand::base::{
     Annotatable, DeriveResolution, Indeterminate, ResolverExpand, SyntaxExtension,
@@ -16,12 +17,15 @@ use rustc_expand::compile_declarative_macro;
 use rustc_expand::expand::{
     AstFragment, AstFragmentKind, Invocation, InvocationKind, SupportsMacroExpansion,
 };
-use rustc_hir::StabilityLevel;
-use rustc_hir::attrs::{CfgEntry, StrippedCfgItem};
+use rustc_feature::Features;
+use rustc_hir::attrs::{AttributeKind, CfgEntry, StrippedCfgItem};
 use rustc_hir::def::{self, DefKind, MacroKinds, Namespace, NonMacroAttrKind};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
+use rustc_hir::{Attribute, StabilityLevel};
+use rustc_middle::dep_graph::DepContext;
 use rustc_middle::middle::stability;
 use rustc_middle::ty::{RegisteredTools, TyCtxt};
+use rustc_session::Session;
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::{
     LEGACY_DERIVE_HELPERS, OUT_OF_SCOPE_MACRO_CALLS, UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
@@ -122,35 +126,38 @@ fn fast_print_path(path: &ast::Path) -> Symbol {
 
 pub(crate) fn registered_tools(tcx: TyCtxt<'_>, (): ()) -> RegisteredTools {
     let (_, pre_configured_attrs) = &*tcx.crate_for_resolver(()).borrow();
-    registered_tools_ast(tcx.dcx(), pre_configured_attrs)
+    registered_tools_ast(tcx.dcx(), pre_configured_attrs, tcx.sess(), tcx.features())
 }
 
 pub fn registered_tools_ast(
     dcx: DiagCtxtHandle<'_>,
     pre_configured_attrs: &[ast::Attribute],
+    sess: &Session,
+    features: &Features,
 ) -> RegisteredTools {
     let mut registered_tools = RegisteredTools::default();
-    for attr in attr::filter_by_name(pre_configured_attrs, sym::register_tool) {
-        for meta_item_inner in attr.meta_item_list().unwrap_or_default() {
-            match meta_item_inner.ident() {
-                Some(ident) => {
-                    if let Some(old_ident) = registered_tools.replace(ident) {
-                        dcx.emit_err(errors::ToolWasAlreadyRegistered {
-                            span: ident.span,
-                            tool: ident,
-                            old_ident_span: old_ident.span,
-                        });
-                    }
-                }
-                None => {
-                    dcx.emit_err(errors::ToolOnlyAcceptsIdentifiers {
-                        span: meta_item_inner.span(),
-                        tool: sym::register_tool,
-                    });
-                }
+
+    if let Some(Attribute::Parsed(AttributeKind::RegisterTool(tools, _))) =
+        AttributeParser::parse_limited(
+            sess,
+            pre_configured_attrs,
+            sym::register_tool,
+            DUMMY_SP,
+            DUMMY_NODE_ID,
+            Some(features),
+        )
+    {
+        for tool in tools {
+            if let Some(old_tool) = registered_tools.replace(tool) {
+                dcx.emit_err(errors::ToolWasAlreadyRegistered {
+                    span: tool.span,
+                    tool,
+                    old_ident_span: old_tool.span,
+                });
             }
         }
     }
+
     // We implicitly add `rustfmt`, `clippy`, `diagnostic`, `miri` and `rust_analyzer` to known
     // tools, but it's not an error to register them explicitly.
     let predefined_tools =
diff --git a/tests/ui/tool-attributes/invalid-tool.rs b/tests/ui/tool-attributes/invalid-tool.rs
@@ -1,6 +1,6 @@
 #![feature(register_tool)]
 
 #![register_tool(1)]
-//~^ ERROR `register_tool` only accepts identifiers
+//~^ ERROR malformed `register_tool` attribute input
 
 fn main() {}
diff --git a/tests/ui/tool-attributes/invalid-tool.stderr b/tests/ui/tool-attributes/invalid-tool.stderr
@@ -1,8 +1,12 @@
-error: `register_tool` only accepts identifiers
-  --> $DIR/invalid-tool.rs:3:18
+error[E0539]: malformed `register_tool` attribute input
+  --> $DIR/invalid-tool.rs:3:1
    |
 LL | #![register_tool(1)]
-   |                  ^ not an identifier
+   | ^^^^^^^^^^^^^^^^^-^^
+   | |                |
+   | |                expected a valid identifier here
+   | help: must be of the form: `#![register_tool(tool1, tool2, ...)]`
 
 error: aborting due to 1 previous error
 
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/tool-attributes/nested-disallowed.rs b/tests/ui/tool-attributes/nested-disallowed.rs
@@ -1,4 +1,4 @@
 #![feature(register_tool)]
-#![register_tool(foo::bar)] //~ ERROR only accepts identifiers
+#![register_tool(foo::bar)] //~ ERROR tools are always a single identifier, not paths with multiple segments
 
 fn main() {}
diff --git a/tests/ui/tool-attributes/nested-disallowed.stderr b/tests/ui/tool-attributes/nested-disallowed.stderr
@@ -1,8 +1,14 @@
-error: `register_tool` only accepts identifiers
+error: tools are always a single identifier, not paths with multiple segments
   --> $DIR/nested-disallowed.rs:2:18
    |
 LL | #![register_tool(foo::bar)]
-   |                  ^^^^^^^^ not an identifier
+   |                  ^^^^^^^^
+   |
+help: did you maybe mean `foo`?
+  --> $DIR/nested-disallowed.rs:2:18
+   |
+LL | #![register_tool(foo::bar)]
+   |                  ^^^
 
 error: aborting due to 1 previous error
 
