port #[register_tool] to the new attribute parsing infrastructure

Author: jdonszelmann

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}`?

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -1,5 +1,5 @@
 use super::prelude::*;
-use crate::session_diagnostics::{FeatureExpectedSingleWord, LimitInvalid};
+use crate::session_diagnostics::{ExpectedSingleWord, LimitInvalid};
 
 pub(crate) struct CrateNameParser;
 
@@ -186,7 +186,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,

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::debugger::DebuggerViualizerParser;
 use crate::attributes::deprecation::DeprecationParser;
@@ -169,6 +169,7 @@ attribute_parsers!(
         Combine<FeatureParser>,
         Combine<ForceTargetFeatureParser>,
         Combine<LinkParser>,
+        Combine<RegisterToolParser>,
         Combine<ReprParser>,
         Combine<TargetFeatureParser>,
         Combine<UnstableFeatureBoundParser>,

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,
 

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_hir/src/attrs/data_structures.rs

@@ -653,6 +653,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 },
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -84,6 +84,7 @@ impl AttributeKind {
             ProcMacroDerive { .. } => No,
             PubTransparent(..) => Yes,
             RecursionLimit { .. } => No,
+            RegisterTool(..) => No,
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcCoherenceIsCore(..) => No,

compiler/rustc_passes/src/check_attr.rs

@@ -284,6 +284,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::RustcCoherenceIsCore(..)
                     | AttributeKind::DebuggerVisualizer(..)
                     | AttributeKind::Feature(..)
+                    | AttributeKind::RegisterTool(..)
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);

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

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)]