Rollup merge of #155193 - JonathanBrouwer:args_used_check, r=jdonszelmann

JonathanBrouwer · web-flow · commit bdb51ea8ea25 · 2026-06-01T19:35:43.000+02:00
Check arguments of attributes where no arguments are expected This PR does the following: - Add a debug assertion to `rustc_attr_parsing`, to ensure we never forget to check the arguments of a meta item again - Removes the unused `#[derive(Clone)]` from `ArgParser` as that would break this debug assertion - **[BREAKING]** Properly check that `#[inline(always(...))]` gets no arguments - **[BREAKING]** Properly check that `#[instruction_set(arm::a32(...))]` gets no arguments - **[BREAKING]** Properly check that `#[macro_export(local_inner_macros(...))]` gets no arguments. Fixes #154977 - **[BREAKING]** Properly check that `#[used(compiler(...))]` gets no arguments. - Properly check that `#[optimize(size(...))]` gets no arguments. - Properly check that `#[coverage(on(...))]` gets no arguments. - Properly check that `#[rustc_dump_layout(debug(...))]` gets no arguments. - Properly check that `#[rustc_abi(debug(...))]` gets no arguments. - Properly check that `#![test_runner(arg(...))]` gets no arguments. - Properly check that `#[rustc_must_implement_one_of(arg(...))]` gets no arguments. - Properly check that `#[allow_internal_unstable(arg(...))]` gets no arguments. - Properly check that `#[unstable_feature_bound(arg(...))]` gets no arguments. - Properly check that `#[rustc_allow_const_fn_unstable(arg(...))]` gets no arguments. - Properly check that `#[rustc_if_this_changed(arg(...))]` gets no arguments. - Properly check that `#[rustc_then_this_would_need(arg(...))]` gets no arguments. r? @jdonszelmann
diff --git a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
@@ -91,7 +91,7 @@ fn parse_unstable(
 
     for param in list.mixed() {
         let param_span = param.span();
-        if let Some(ident) = param.meta_item().and_then(|i| i.path().word()) {
+        if let Some(ident) = param.meta_item_no_args().and_then(|i| i.path().word()) {
             res.push(ident.name);
         } else {
             cx.emit_err(session_diagnostics::ExpectsFeatures {
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -26,7 +26,7 @@ impl SingleAttributeParser for OptimizeParser {
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
         let single = cx.expect_single_element_list(args, cx.attr_span)?;
 
-        let res = match single.meta_item().and_then(|i| i.path().word().map(|i| i.name)) {
+        let res = match single.meta_item_no_args().and_then(|i| i.path().word().map(|i| i.name)) {
             Some(sym::size) => OptimizeAttr::Size,
             Some(sym::speed) => OptimizeAttr::Speed,
             Some(sym::none) => OptimizeAttr::DoNotOptimize,
@@ -80,7 +80,7 @@ impl SingleAttributeParser for CoverageParser {
         let mut fail_incorrect_argument =
             |span| cx.adcx().expected_specific_argument(span, &[sym::on, sym::off]);
 
-        let Some(arg) = arg.meta_item() else {
+        let Some(arg) = arg.meta_item_no_args() else {
             fail_incorrect_argument(arg.span());
             return None;
         };
@@ -373,7 +373,7 @@ impl AttributeParser for UsedParser {
                         return;
                     };
 
-                    match l.meta_item().and_then(|i| i.path().word_sym()) {
+                    match l.meta_item_no_args().and_then(|i| i.path().word_sym()) {
                         Some(sym::compiler) => {
                             if !cx.features().used_with_arg() {
                                 feature_err(
diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_const.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_const.rs
@@ -17,6 +17,7 @@ impl AttributeParser for OnConstParser {
         |this, cx, args| {
             if !cx.features().diagnostic_on_const() {
                 // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
+                args.ignore_args();
                 return;
             }
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs
@@ -20,6 +20,7 @@ impl OnMoveParser {
     fn parse<'sess>(&mut self, cx: &mut AcceptContext<'_, 'sess>, args: &ArgParser, mode: Mode) {
         if !cx.features().diagnostic_on_move() {
             // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
+            args.ignore_args();
             return;
         }
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs b/compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs
@@ -18,6 +18,7 @@ impl OnUnknownParser {
             && !features.diagnostic_on_unknown()
         {
             // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
+            args.ignore_args();
             return;
         }
         let span = cx.attr_span;
diff --git a/compiler/rustc_attr_parsing/src/attributes/doc.rs b/compiler/rustc_attr_parsing/src/attributes/doc.rs
@@ -190,6 +190,8 @@ impl DocParser {
 
                 // FIXME: convert list into a Vec of `AttributeKind` because current code is awful.
                 for attr in list.mixed() {
+                    // Arguments of `attr` are checked via the span, so can be safely ignored
+                    attr.ignore_args();
                     self.attribute.test_attrs.push(attr.span());
                 }
             }
diff --git a/compiler/rustc_attr_parsing/src/attributes/dummy.rs b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
@@ -14,7 +14,8 @@ impl SingleAttributeParser for RustcDummyParser {
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
     const TEMPLATE: AttributeTemplate = template!(Word); // Anything, really
 
-    fn convert(_: &mut AcceptContext<'_, '_>, _: &ArgParser) -> Option<AttributeKind> {
+    fn convert(_: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
+        args.ignore_args();
         Some(AttributeKind::RustcDummy)
     }
 }
diff --git a/compiler/rustc_attr_parsing/src/attributes/inline.rs b/compiler/rustc_attr_parsing/src/attributes/inline.rs
@@ -39,7 +39,7 @@ impl SingleAttributeParser for InlineParser {
             ArgParser::List(list) => {
                 let l = cx.expect_single(list)?;
 
-                match l.meta_item().and_then(|i| i.path().word_sym()) {
+                match l.meta_item_no_args().and_then(|i| i.path().word_sym()) {
                     Some(sym::always) => {
                         Some(AttributeKind::Inline(InlineAttr::Always, cx.attr_span))
                     }
diff --git a/compiler/rustc_attr_parsing/src/attributes/instruction_set.rs b/compiler/rustc_attr_parsing/src/attributes/instruction_set.rs
@@ -21,7 +21,7 @@ impl SingleAttributeParser for InstructionSetParser {
         const POSSIBLE_ARM_SYMBOLS: &[Symbol] = &[sym::a32, sym::t32];
         let maybe_meta_item = cx.expect_single_element_list(args, cx.attr_span)?;
 
-        let Some(meta_item) = maybe_meta_item.meta_item() else {
+        let Some(meta_item) = maybe_meta_item.meta_item_no_args() else {
             cx.adcx().expected_specific_argument(maybe_meta_item.span(), POSSIBLE_SYMBOLS);
             return None;
         };
diff --git a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
@@ -145,7 +145,7 @@ impl SingleAttributeParser for MacroExportParser {
                     cx.adcx().warn_ill_formed_attribute_input(INVALID_MACRO_EXPORT_ARGUMENTS);
                     return None;
                 };
-                match l.meta_item().and_then(|i| i.path().word_sym()) {
+                match l.meta_item_no_args().and_then(|i| i.path().word_sym()) {
                     Some(sym::local_inner_macros) => true,
                     _ => {
                         cx.adcx().warn_ill_formed_attribute_input(INVALID_MACRO_EXPORT_ARGUMENTS);
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs
@@ -98,7 +98,7 @@ impl CombineAttributeParser for RustcDumpLayoutParser {
 
         let mut result = Vec::new();
         for item in items.mixed() {
-            let Some(arg) = item.meta_item() else {
+            let Some(arg) = item.meta_item_no_args() else {
                 cx.adcx().expected_not_literal(item.span());
                 continue;
             };
diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs
@@ -43,7 +43,7 @@ impl SingleAttributeParser for RustcMustImplementOneOfParser {
 
         let mut errored = false;
         for argument in inputs {
-            let Some(meta) = argument.meta_item() else {
+            let Some(meta) = argument.meta_item_no_args() else {
                 cx.adcx().expected_identifier(argument.span());
                 return None;
             };
@@ -820,7 +820,7 @@ impl SingleAttributeParser for RustcIfThisChangedParser {
             ArgParser::NoArgs => Some(AttributeKind::RustcIfThisChanged(cx.attr_span, None)),
             ArgParser::List(list) => {
                 let item = cx.expect_single(list)?;
-                let Some(ident) = item.meta_item().and_then(|item| item.ident()) else {
+                let Some(ident) = item.meta_item_no_args().and_then(|item| item.ident()) else {
                     cx.adcx().expected_identifier(item.span());
                     return None;
                 };
@@ -878,7 +878,7 @@ impl CombineAttributeParser for RustcThenThisWouldNeedParser {
             cx.emit_err(AttributeRequiresOpt { span: cx.attr_span, opt: "-Z query-dep-graph" });
         }
         let item = cx.expect_single_element_list(args, cx.attr_span)?;
-        let Some(ident) = item.meta_item().and_then(|item| item.ident()) else {
+        let Some(ident) = item.meta_item_no_args().and_then(|item| item.ident()) else {
             cx.adcx().expected_identifier(item.span());
             return None;
         };
diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
@@ -123,7 +123,7 @@ impl SingleAttributeParser for RustcAbiParser {
         let mut fail_incorrect_argument =
             |span| cx.adcx().expected_specific_argument(span, &[sym::assert_eq, sym::debug]);
 
-        let Some(arg) = arg.meta_item() else {
+        let Some(arg) = arg.meta_item_no_args() else {
             fail_incorrect_argument(args.span);
             return None;
         };
@@ -173,7 +173,7 @@ impl SingleAttributeParser for TestRunnerParser {
     fn convert(cx: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {
         let single = cx.expect_single_element_list(args, cx.attr_span)?;
 
-        let Some(meta) = single.meta_item() else {
+        let Some(meta) = single.meta_item_no_args() else {
             cx.adcx().expected_not_literal(single.span());
             return None;
         };
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
@@ -4,6 +4,8 @@ use std::collections::btree_map::Entry;
 use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::sync::LazyLock;
+#[cfg(debug_assertions)]
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use rustc_ast::{AttrStyle, MetaItemLit, Safety};
 use rustc_data_structures::sync::{DynSend, DynSync};
@@ -405,6 +407,8 @@ impl<'f, 'sess: 'f> SharedContext<'f, 'sess> {
         kind: EmitAttribute,
         span: impl Into<MultiSpan>,
     ) {
+        #[cfg(debug_assertions)]
+        self.has_lint_been_emitted.store(true, Ordering::Relaxed);
         if !matches!(
             self.should_emit,
             ShouldEmit::ErrorsAndLints { .. } | ShouldEmit::EarlyFatal { also_emit_lints: true }
@@ -744,6 +748,11 @@ pub struct SharedContext<'p, 'sess> {
     pub(crate) target: rustc_hir::Target,
 
     pub(crate) emit_lint: &'p mut dyn FnMut(LintId, MultiSpan, EmitAttribute),
+
+    /// This atomic bool keeps track of whether any lint has been emitted.
+    /// This is used for the arguments-used check.
+    #[cfg(debug_assertions)]
+    pub(crate) has_lint_been_emitted: AtomicBool,
 }
 
 /// Context given to every attribute parser during finalization.
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
@@ -1,4 +1,6 @@
 use std::convert::identity;
+#[cfg(debug_assertions)]
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use rustc_ast as ast;
 use rustc_ast::token::DocFragmentKind;
@@ -228,6 +230,8 @@ impl<'sess> AttributeParser<'sess> {
                 target_span,
                 target,
                 emit_lint: &mut emit_lint,
+                #[cfg(debug_assertions)]
+                has_lint_been_emitted: AtomicBool::new(false),
             },
             attr_span,
             inner_span,
@@ -395,6 +399,8 @@ impl<'sess> AttributeParser<'sess> {
                                 target_span,
                                 target,
                                 emit_lint: &mut emit_lint,
+                                #[cfg(debug_assertions)]
+                                has_lint_been_emitted: AtomicBool::new(false),
                             },
                             attr_span,
                             inner_span,
@@ -409,6 +415,10 @@ impl<'sess> AttributeParser<'sess> {
                         finalizers.push(accept.finalizer);
 
                         Self::check_target(&accept.allowed_targets, &mut cx);
+                        #[cfg(debug_assertions)]
+                        if !cx.shared.has_lint_been_emitted.load(Ordering::Relaxed) {
+                            cx.shared.cx.check_args_used(&attr, &args)
+                        }
                     } else {
                         let attr = AttrItem {
                             path: attr_path.clone(),
@@ -442,7 +452,14 @@ impl<'sess> AttributeParser<'sess> {
         early_parsed_state.finalize_early_parsed_attributes(&mut attributes);
         for f in &finalizers {
             if let Some(attr) = f(&mut FinalizeContext {
-                shared: SharedContext { cx: self, target_span, target, emit_lint: &mut emit_lint },
+                shared: SharedContext {
+                    cx: self,
+                    target_span,
+                    target,
+                    emit_lint: &mut emit_lint,
+                    #[cfg(debug_assertions)]
+                    has_lint_been_emitted: AtomicBool::new(false),
+                },
                 all_attrs: &attr_paths,
             }) {
                 attributes.push(Attribute::Parsed(attr));
@@ -456,6 +473,26 @@ impl<'sess> AttributeParser<'sess> {
         attributes
     }
 
+    #[cfg(debug_assertions)]
+    /// Checks whether all `ArgParser`s were observed by an attribute parser at least once
+    /// This check exists because otherwise it is too easy to accidentally ignore the arguments of an attribute
+    fn check_args_used(&self, attr: &ast::Attribute, args: &ArgParser) {
+        if let ArgParser::List(items) = args {
+            for item in items.mixed() {
+                if let crate::parser::MetaItemOrLitParser::MetaItemParser(item) = item {
+                    if !item.are_args_checked() {
+                        self.dcx().span_delayed_bug(
+                            item.span(),
+                            "attribute args were not properly checked",
+                        );
+                        return;
+                    }
+                    self.check_args_used(attr, item.args());
+                }
+            }
+        }
+    }
+
     /// Returns whether there is a parser for an attribute with this name
     pub fn is_parsed_attribute(path: &[Symbol]) -> bool {
         /// The list of attributes that are parsed attributes,
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
diff --git a/tests/ui/attributes/args-checked.rs b/tests/ui/attributes/args-checked.rs
diff --git a/tests/ui/attributes/args-checked.stderr b/tests/ui/attributes/args-checked.stderr

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ impl AttributeParser for OnConstParser {`
`17`	`17`	`\|this, cx, args\| {`
`18`	`18`	`if !cx.features().diagnostic_on_const() {`
`19`	`19`	// `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
	`20`	`+ args.ignore_args();`
`20`	`21`	`return;`
`21`	`22`	`}`
`22`	`23`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ impl OnMoveParser {`
`20`	`20`	`fn parse<'sess>(&mut self, cx: &mut AcceptContext<'_, 'sess>, args: &ArgParser, mode: Mode) {`
`21`	`21`	`if !cx.features().diagnostic_on_move() {`
`22`	`22`	// `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
	`23`	`+ args.ignore_args();`
`23`	`24`	`return;`
`24`	`25`	`}`
`25`	`26`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ impl OnUnknownParser {`
`18`	`18`	`&& !features.diagnostic_on_unknown()`
`19`	`19`	`{`
`20`	`20`	// `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
	`21`	`+ args.ignore_args();`
`21`	`22`	`return;`
`22`	`23`	`}`
`23`	`24`	`let span = cx.attr_span;`
Original file line number	Diff line number	Diff line change
`@@ -190,6 +190,8 @@ impl DocParser {`
`190`	`190`
`191`	`191`	// FIXME: convert list into a Vec of `AttributeKind` because current code is awful.
`192`	`192`	`for attr in list.mixed() {`
	`193`	+ // Arguments of `attr` are checked via the span, so can be safely ignored
	`194`	`+ attr.ignore_args();`
`193`	`195`	`self.attribute.test_attrs.push(attr.span());`
`194`	`196`	`}`
`195`	`197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,8 @@ impl SingleAttributeParser for RustcDummyParser {`
`14`	`14`	`const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);`
`15`	`15`	`const TEMPLATE: AttributeTemplate = template!(Word); // Anything, really`
`16`	`16`
`17`		`- fn convert(_: &mut AcceptContext<'_, '_>, _: &ArgParser) -> Option<AttributeKind> {`
	`17`	`+ fn convert(_: &mut AcceptContext<'_, '_>, args: &ArgParser) -> Option<AttributeKind> {`
	`18`	`+ args.ignore_args();`
`18`	`19`	`Some(AttributeKind::RustcDummy)`
`19`	`20`	`}`
`20`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ impl SingleAttributeParser for InlineParser {`
`39`	`39`	`ArgParser::List(list) => {`
`40`	`40`	`let l = cx.expect_single(list)?;`
`41`	`41`
`42`		`- match l.meta_item().and_then(\|i\| i.path().word_sym()) {`
	`42`	`+ match l.meta_item_no_args().and_then(\|i\| i.path().word_sym()) {`
`43`	`43`	`Some(sym::always) => {`
`44`	`44`	`Some(AttributeKind::Inline(InlineAttr::Always, cx.attr_span))`
`45`	`45`	`}`