Add a helper expect_no_args method

Author: GrigorenkoPV

compiler/rustc_attr_parsing/src/attributes/lint_helpers.rs

@@ -1,6 +1,6 @@
 use rustc_attr_data_structures::AttributeKind;
 use rustc_feature::{AttributeTemplate, template};
-use rustc_span::{Symbol, sym};
+use rustc_span::{ErrorGuaranteed, Symbol, sym};
 
 use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
 use crate::context::{AcceptContext, Stage};
@@ -14,8 +14,8 @@ impl<S: Stage> SingleAttributeParser<S> for AsPtrParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
     const TEMPLATE: AttributeTemplate = template!(Word);
 
-    fn convert(cx: &mut AcceptContext<'_, '_, S>, _args: &ArgParser<'_>) -> Option<AttributeKind> {
-        // FIXME: check that there's no args (this is currently checked elsewhere)
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let _: Result<(), ErrorGuaranteed> = cx.expect_no_args(args);
         Some(AttributeKind::AsPtr(cx.attr_span))
     }
 }

compiler/rustc_attr_parsing/src/attributes/resolution.rs

@@ -2,7 +2,7 @@ use core::mem;
 
 use rustc_attr_data_structures::AttributeKind;
 use rustc_feature::{AttributeTemplate, template};
-use rustc_span::{Symbol, sym};
+use rustc_span::{ErrorGuaranteed, Symbol, sym};
 
 use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
 use crate::context::{AcceptContext, Stage};
@@ -33,13 +33,7 @@ impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
                 cx.unexpected_literal(arg.span());
                 continue;
             };
-            if let Some(span) = match arg.args() {
-                ArgParser::NoArgs => None,
-                ArgParser::List(args) => Some(args.span),
-                ArgParser::NameValue(args) => Some(args.eq_span.to(args.value_span)),
-            } {
-                cx.unexpected_literal(span);
-            }
+            let _: Result<(), ErrorGuaranteed> = cx.expect_no_args(arg.args());
             let path = arg.path();
             let (key, skip): (Symbol, &mut bool) = match path.word_sym() {
                 Some(key @ sym::array) => (key, &mut array),

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -139,7 +139,8 @@ impl<S: Stage> SingleAttributeParser<S> for ConstStabilityIndirectParser {
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
     const TEMPLATE: AttributeTemplate = template!(Word);
 
-    fn convert(_cx: &mut AcceptContext<'_, '_, S>, _args: &ArgParser<'_>) -> Option<AttributeKind> {
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let _: Result<(), ErrorGuaranteed> = cx.expect_no_args(args);
         Some(AttributeKind::ConstStabilityIndirect)
     }
 }

compiler/rustc_attr_parsing/src/context.rs

@@ -322,6 +322,24 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
             },
         })
     }
+
+    pub(crate) fn expect_no_args(&self, args: &ArgParser<'_>) -> Result<(), ErrorGuaranteed> {
+        if let Some(span) = match args {
+            ArgParser::NoArgs => None,
+            ArgParser::List(args) => Some(args.span),
+            ArgParser::NameValue(args) => Some(args.eq_span.to(args.value_span)),
+        } {
+            Err(self.emit_err(AttributeParseError {
+                span,
+                attr_span: self.attr_span,
+                template: self.template.clone(),
+                attribute: self.attr_path.clone(),
+                reason: AttributeParseErrorReason::UnexpectedArguments,
+            }))
+        } else {
+            Ok(())
+        }
+    }
 }
 
 impl<'f, 'sess, S: Stage> Deref for AcceptContext<'f, 'sess, S> {

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -479,6 +479,7 @@ pub(crate) enum AttributeParseErrorReason {
     ExpectedSingleArgument,
     ExpectedList,
     UnexpectedLiteral,
+    UnexpectedArguments,
     ExpectedNameValue(Option<Symbol>),
     DuplicateKey(Symbol),
     ExpectedSpecificArgument { possibilities: Vec<&'static str>, strings: bool },
@@ -533,6 +534,9 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError {
                 diag.span_label(self.span, format!("didn't expect a literal here"));
                 diag.code(E0565);
             }
+            AttributeParseErrorReason::UnexpectedArguments => {
+                diag.span_label(self.span, format!("didn't expect any arguments here"));
+            }
             AttributeParseErrorReason::ExpectedNameValue(None) => {
                 diag.span_label(
                     self.span,

compiler/rustc_parse/src/validate_attr.rs

@@ -286,6 +286,9 @@ fn emit_malformed_attribute(
     if matches!(
         name,
         sym::inline
+            | sym::rustc_as_ptr
+            | sym::rustc_pub_transparent
+            | sym::rustc_const_stable_indirect
             | sym::rustc_force_inline
             | sym::rustc_confusables
             | sym::repr

tests/ui/attributes/rustc_skip_during_method_dispatch.stderr

@@ -43,13 +43,13 @@ LL | #[rustc_skip_during_method_dispatch(slice)]
    | |                                   valid arguments are `array` or `boxed_slice`
    | help: must be of the form: `#[rustc_skip_during_method_dispatch(array, boxed_slice)]`
 
-error[E0565]: malformed `rustc_skip_during_method_dispatch` attribute input
+error[E0539]: malformed `rustc_skip_during_method_dispatch` attribute input
   --> $DIR/rustc_skip_during_method_dispatch.rs:23:1
    |
 LL | #[rustc_skip_during_method_dispatch(array = true)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^------^^
    | |                                         |
-   | |                                         didn't expect a literal here
+   | |                                         didn't expect any arguments here
    | help: must be of the form: `#[rustc_skip_during_method_dispatch(array, boxed_slice)]`
 
 error[E0565]: malformed `rustc_skip_during_method_dispatch` attribute input