better diagnostics for arguments

Author: jdonszelmann

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -226,7 +226,7 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
  const ATTRIBUTES: AcceptMapping<Self, S> =
  &[(&[sym::naked], template!(Word), |this, cx, args| {
  if let Err(span) = args.no_args() {
- cx.expected_no_args(span);
+ cx.expected_no_args(&cx.attr_path, span);
  return;
  }
 

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -214,7 +214,7 @@ impl<S: Stage> CombineAttributeParser<S> for FeatureParser {
  continue;
  };
  if let Err(arg_span) = elem.args().no_args() {
- cx.expected_no_args(arg_span);
+ cx.expected_no_args(&elem.path().get_attribute_path(), arg_span);
  continue;
  }
 

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -89,7 +89,10 @@ impl<S: Stage> AttributeParser<S> for MacroUseParser {
  continue;
  };
  if let Err(err_span) = item.args().no_args() {
- cx.expected_no_args(err_span);
+ cx.expected_no_args(
+ &item.path().get_attribute_path(),
+ err_span,
+ );
  continue;
  }
  let Some(item) = item.path().word() else {

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -280,7 +280,7 @@ impl<T: NoArgsAttributeParser<S>, S: Stage> SingleAttributeParser<S> for Without
 
  fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
  if let Err(span) = args.no_args() {
- cx.expected_no_args(span);
+ cx.expected_no_args(&cx.attr_path, span);
  }
  Some(T::CREATE(cx.attr_span))
  }

compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs

@@ -88,7 +88,7 @@ fn parse_derive_like<S: Stage>(
  return None;
  }
  if let Err(e) = trait_attr.args().no_args() {
- cx.expected_no_args(e);
+ cx.expected_no_args(&trait_attr.path().get_attribute_path(), e);
  return None;
  };
 
@@ -121,7 +121,7 @@ fn parse_derive_like<S: Stage>(
  return None;
  };
  if let Err(e) = attr.args().no_args() {
- cx.expected_no_args(e);
+ cx.expected_no_args(&attr.path().get_attribute_path(), e);
  return None;
  };
  let Some(ident) = attr.path().word() else {

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -42,7 +42,7 @@ impl<S: Stage> SingleAttributeParser<S> for RustcObjectLifetimeDefaultParser {
 
  fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
  if let Err(span) = args.no_args() {
- cx.expected_no_args(span);
+ cx.expected_no_args(&cx.attr_path, span);
  return None;
  }
 

compiler/rustc_attr_parsing/src/attributes/traits.rs

@@ -35,7 +35,7 @@ impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
  continue;
  };
  if let Err(span) = arg.args().no_args() {
- cx.expected_no_args(span);
+ cx.expected_no_args(&arg.path().get_attribute_path(), span);
  }
  let path = arg.path();
  let (key, skip): (Symbol, &mut bool) = match path.word_sym() {

compiler/rustc_attr_parsing/src/context.rs

@@ -451,13 +451,13 @@ impl<'f, 'sess: 'f, S: Stage> AcceptContext<'f, 'sess, S> {
  })
  }
 
- pub(crate) fn expected_no_args(&self, args_span: Span) -> ErrorGuaranteed {
+ pub(crate) fn expected_no_args(&self, path: &AttrPath, args_span: Span) -> ErrorGuaranteed {
  self.emit_err(AttributeParseError {
  span: args_span,
  attr_span: self.attr_span,
  template: self.template.clone(),
  attribute: self.attr_path.clone(),
- reason: AttributeParseErrorReason::ExpectedNoArgs,
+ reason: AttributeParseErrorReason::ExpectedNoArgs { path },
  attr_style: self.attr_style,
  })
  }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -587,7 +587,9 @@ pub(crate) struct LinkOrdinalOutOfRange {
 }
 
 pub(crate) enum AttributeParseErrorReason<'a> {
- ExpectedNoArgs,
+ ExpectedNoArgs {
+ path: &'a AttrPath,
+ },
  ExpectedStringLiteral {
  byte_string: Option<Span>,
  },
@@ -619,13 +621,28 @@ pub(crate) struct AttributeParseError<'a> {
  pub(crate) reason: AttributeParseErrorReason<'a>,
 }
 
+/// based on the attribute's template we add relevant suggestions to the error automatically.
+enum DefaultSuggestionStyle {
+ /// give a hint about the valid forms of the attribute.
+ /// Useful if there's already a better suggestion given than the automatic ones can provide
+ /// but we'd still like to show which syntax forms are valid.
+ Hint,
+ /// Use the template to suggest changes to the attribute
+ Suggestion,
+ /// Don't show any default suggestions
+ None,
+}
+
 impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
  fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
  let name = self.attribute.to_string();
 
  let mut diag = Diag::new(dcx, level, format!("malformed `{name}` attribute input"));
  diag.span(self.attr_span);
  diag.code(E0539);
+
+ let mut show_default_suggestions = DefaultSuggestionStyle::Suggestion;
+
  match self.reason {
  AttributeParseErrorReason::ExpectedStringLiteral { byte_string } => {
  if let Some(start_point_span) = byte_string {
@@ -637,7 +654,7 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
  );
  diag.note("expected a normal string literal, not a byte string literal");
 
- return diag;
+ show_default_suggestions = DefaultSuggestionStyle::None;
  } else {
  diag.span_label(self.span, "expected a string literal here");
  }
@@ -663,9 +680,19 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
  diag.span_label(self.span, "didn't expect a literal here");
  diag.code(E0565);
  }
- AttributeParseErrorReason::ExpectedNoArgs => {
+ AttributeParseErrorReason::ExpectedNoArgs { path } => {
  diag.span_label(self.span, "didn't expect any arguments here");
  diag.code(E0565);
+
+ if path.span != self.attribute.span {
+ diag.span_suggestion(
+ path.span.to(self.span),
+ "remove this argument",
+ path,
+ Applicability::MachineApplicable,
+ );
+ show_default_suggestions = DefaultSuggestionStyle::Hint;
+ }
  }
  AttributeParseErrorReason::ExpectedNameValue(None) => {
  // If the span is the entire attribute, the suggestion we add below this match already contains enough information
@@ -756,18 +783,27 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> {
  if let Some(link) = self.template.docs {
  diag.note(format!("for more information, visit <{link}>"));
  }
+
  let suggestions = self.template.suggestions(self.attr_style, &name);
+ let text = match show_default_suggestions {
+ DefaultSuggestionStyle::Hint => {
+ if suggestions.len() == 1 {
+ "the only valid form of the attribute is"
+ } else {
+ "these are the valid forms of the attribute"
+ }
+ }
+ DefaultSuggestionStyle::Suggestion => {
+ if suggestions.len() == 1 {
+ "must be of the form"
+ } else {
+ "try changing it to one of the following valid forms of the attribute"
+ }
+ }
+ DefaultSuggestionStyle::None => return diag,
+ };
 
- diag.span_suggestions(
- self.attr_span,
- if suggestions.len() == 1 {
- "must be of the form"
- } else {
- "try changing it to one of the following valid forms of the attribute"
- },
- suggestions,
- Applicability::HasPlaceholders,
- );
+ diag.span_suggestions(self.attr_span, text, suggestions, Applicability::HasPlaceholders);
 
  diag
  }

tests/ui/attributes/invalid-macro-use.stderr

@@ -43,7 +43,12 @@ LL | #[macro_use(a = "b")]
  | didn't expect any arguments here
  |
  = note: for more information, visit <https://doc.rust-lang.org/reference/macros-by-example.html#the-macro_use-attribute>
-help: try changing it to one of the following valid forms of the attribute
+help: remove this argument
+ |
+LL - #[macro_use(a = "b")]
+LL + #[macro_use(a)]
+ |
+help: these are the valid forms of the attribute
  |
 LL - #[macro_use(a = "b")]
 LL + #[macro_use(name1, name2, ...)]
@@ -61,7 +66,12 @@ LL | #[macro_use(a(b))]
  | didn't expect any arguments here
  |
  = note: for more information, visit <https://doc.rust-lang.org/reference/macros-by-example.html#the-macro_use-attribute>
-help: try changing it to one of the following valid forms of the attribute
+help: remove this argument
+ |
+LL - #[macro_use(a(b))]
+LL + #[macro_use(a)]
+ |
+help: these are the valid forms of the attribute
  |
 LL - #[macro_use(a(b))]
 LL + #[macro_use(name1, name2, ...)]