Rollup of 5 pull requests

compiler/rustc_attr_parsing/messages.ftl

@@ -50,11 +50,6 @@ attr_parsing_expects_feature_list =
 attr_parsing_expects_features =
     `{$name}` expects feature names
 
-attr_parsing_ill_formed_attribute_input = {$num_suggestions ->
-        [1] attribute must be of the form {$suggestions}
-        *[other] valid forms for the attribute are {$suggestions}
-    }
-
 attr_parsing_import_name_type_raw =
     import name type can only be used with link kind `raw-dylib`
 
@@ -213,10 +208,6 @@ attr_parsing_stability_outside_std = stability attributes may not be used outsid
 attr_parsing_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes
     .help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
 
-attr_parsing_unknown_meta_item =
-    unknown meta item '{$item}'
-    .label = expected one of {$expected}
-
 attr_parsing_unknown_version_literal =
     unknown version literal format, assuming it refers to a future version
 

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -42,7 +42,7 @@ pub fn parse_cfg<S: Stage>(
     args: &ArgParser,
 ) -> Option<CfgEntry> {
     let ArgParser::List(list) = args else {
-        cx.expected_list(cx.attr_span);
+        cx.expected_list(cx.attr_span, args);
         return None;
     };
     let Some(single) = list.single() else {

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -25,7 +25,7 @@ impl<S: Stage> SingleAttributeParser<S> for OptimizeParser {
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let Some(list) = args.list() else {
-            cx.expected_list(cx.attr_span);
+            cx.expected_list(cx.attr_span, args);
             return None;
         };
 
@@ -478,7 +478,7 @@ fn parse_tf_attribute<S: Stage>(
 ) -> impl IntoIterator<Item = (Symbol, Span)> {
     let mut features = Vec::new();
     let ArgParser::List(list) = args else {
-        cx.expected_list(cx.attr_span);
+        cx.expected_list(cx.attr_span, args);
         return features;
     };
     if list.is_empty() {
@@ -601,7 +601,7 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let Some(list) = args.list() else {
-            cx.expected_list(cx.attr_span);
+            cx.expected_list(cx.attr_span, args);
             return None;
         };
 

compiler/rustc_attr_parsing/src/attributes/confusables.rs

@@ -13,7 +13,7 @@ impl<S: Stage> AttributeParser<S> for ConfusablesParser {
         template!(List: &[r#""name1", "name2", ..."#]),
         |this, cx, args| {
             let Some(list) = args.list() else {
-                cx.expected_list(cx.attr_span);
+                cx.expected_list(cx.attr_span, args);
                 return;
             };
 

compiler/rustc_attr_parsing/src/attributes/debugger.rs

@@ -21,7 +21,7 @@ impl<S: Stage> CombineAttributeParser<S> for DebuggerViualizerParser {
         args: &ArgParser,
     ) -> impl IntoIterator<Item = Self::Item> {
         let Some(l) = args.list() else {
-            cx.expected_list(args.span().unwrap_or(cx.attr_span));
+            cx.expected_list(cx.attr_span, args);
             return None;
         };
         let Some(single) = l.single() else {

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -110,13 +110,12 @@ impl<S: Stage> SingleAttributeParser<S> for DeprecationParser {
                                 Some(get(cx, name, param.span(), param.args(), &suggestion)?);
                         }
                         _ => {
-                            cx.unknown_key(
+                            cx.expected_specific_argument(
                                 param.span(),
-                                param.path().to_string(),
                                 if features.deprecated_suggestion() {
-                                    &["since", "note", "suggestion"]
+                                    &[sym::since, sym::note, sym::suggestion]
                                 } else {
-                                    &["since", "note"]
+                                    &[sym::since, sym::note]
                                 },
                             );
                             return None;

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -106,7 +106,7 @@ impl DocParser {
             }
             Some(sym::attr) => {
                 let Some(list) = args.list() else {
-                    cx.expected_list(cx.attr_span);
+                    cx.expected_list(cx.attr_span, args);
                     return;
                 };
 

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -76,7 +76,7 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
                 return None;
             }
             _ => {
-                cx.expected_list(cx.attr_span);
+                cx.expected_list(cx.attr_span, args);
                 return None;
             }
         };
@@ -379,7 +379,7 @@ impl LinkParser {
             return true;
         }
         let Some(link_cfg) = item.args().list() else {
-            cx.expected_list(item.span());
+            cx.expected_list(item.span(), item.args());
             return true;
         };
         let Some(link_cfg) = link_cfg.single() else {

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -1,9 +1,7 @@
-use rustc_errors::DiagArgValue;
 use rustc_hir::attrs::MacroUseArgs;
 use rustc_session::lint::builtin::INVALID_MACRO_EXPORT_ARGUMENTS;
 
 use super::prelude::*;
-use crate::session_diagnostics::IllFormedAttributeInputLint;
 
 pub(crate) struct MacroEscapeParser;
 impl<S: Stage> NoArgsAttributeParser<S> for MacroEscapeParser {
@@ -101,15 +99,8 @@ impl<S: Stage> AttributeParser<S> for MacroUseParser {
                         }
                     }
                 }
-                ArgParser::NameValue(_) => {
-                    let suggestions = cx.suggestions();
-                    cx.emit_err(IllFormedAttributeInputLint {
-                        num_suggestions: suggestions.len(),
-                        suggestions: DiagArgValue::StrListSepByAnd(
-                            suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
-                        ),
-                        span,
-                    });
+                ArgParser::NameValue(nv) => {
+                    cx.expected_list_or_no_args(nv.args_span());
                 }
             }
         },
@@ -164,16 +155,8 @@ impl<S: Stage> SingleAttributeParser<S> for MacroExportParser {
                     }
                 }
             }
-            ArgParser::NameValue(_) => {
-                let span = cx.attr_span;
-                let suggestions = cx.suggestions();
-                cx.emit_err(IllFormedAttributeInputLint {
-                    num_suggestions: suggestions.len(),
-                    suggestions: DiagArgValue::StrListSepByAnd(
-                        suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
-                    ),
-                    span,
-                });
+            ArgParser::NameValue(nv) => {
+                cx.expected_list_or_no_args(nv.args_span());
                 return None;
             }
         };

compiler/rustc_attr_parsing/src/attributes/must_use.rs

@@ -1,7 +1,4 @@
-use rustc_errors::DiagArgValue;
-
 use super::prelude::*;
-use crate::session_diagnostics::IllFormedAttributeInputLint;
 
 pub(crate) struct MustUseParser;
 
@@ -44,15 +41,8 @@ impl<S: Stage> SingleAttributeParser<S> for MustUseParser {
                     };
                     Some(value_str)
                 }
-                ArgParser::List(_) => {
-                    let suggestions = cx.suggestions();
-                    cx.emit_err(IllFormedAttributeInputLint {
-                        num_suggestions: suggestions.len(),
-                        suggestions: DiagArgValue::StrListSepByAnd(
-                            suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
-                        ),
-                        span: cx.attr_span,
-                    });
+                ArgParser::List(list) => {
+                    cx.expected_nv_or_no_args(list.span);
                     return None;
                 }
             },

compiler/rustc_attr_parsing/src/attributes/proc_macro_attrs.rs

@@ -65,7 +65,7 @@ fn parse_derive_like<S: Stage>(
         if args.no_args().is_ok() && !trait_name_mandatory {
             return Some((None, ThinVec::new()));
         }
-        cx.expected_list(cx.attr_span);
+        cx.expected_list(cx.attr_span, args);
         return None;
     };
     let mut items = list.mixed();
@@ -96,15 +96,15 @@ fn parse_derive_like<S: Stage>(
     let mut attributes = ThinVec::new();
     if let Some(attrs) = items.next() {
         let Some(attr_list) = attrs.meta_item() else {
-            cx.expected_list(attrs.span());
+            cx.unexpected_literal(attrs.span());
             return None;
         };
         if !attr_list.path().word_is(sym::attributes) {
             cx.expected_specific_argument(attrs.span(), &[sym::attributes]);
             return None;
         }
         let Some(attr_list) = attr_list.args().list() else {
-            cx.expected_list(attrs.span());
+            cx.expected_list(attrs.span(), attr_list.args());
             return None;
         };
 

compiler/rustc_attr_parsing/src/attributes/prototype.rs

@@ -27,7 +27,7 @@ impl<S: Stage> SingleAttributeParser<S> for CustomMirParser {
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let Some(list) = args.list() else {
-            cx.expected_list(cx.attr_span);
+            cx.expected_list(cx.attr_span, args);
             return None;
         };
 
@@ -46,9 +46,8 @@ impl<S: Stage> SingleAttributeParser<S> for CustomMirParser {
                 extract_value(cx, sym::dialect, arg, meta_item.span(), &mut dialect, &mut failed);
             } else if let Some(arg) = meta_item.word_is(sym::phase) {
                 extract_value(cx, sym::phase, arg, meta_item.span(), &mut phase, &mut failed);
-            } else if let Some(word) = meta_item.path().word() {
-                let word = word.to_string();
-                cx.unknown_key(meta_item.span(), word, &["dialect", "phase"]);
+            } else if let Some(..) = meta_item.path().word() {
+                cx.expected_specific_argument(meta_item.span(), &[sym::dialect, sym::phase]);
                 failed = true;
             } else {
                 cx.expected_name_value(meta_item.span(), None);

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -33,7 +33,7 @@ impl<S: Stage> CombineAttributeParser<S> for ReprParser {
         let mut reprs = Vec::new();
 
         let Some(list) = args.list() else {
-            cx.expected_list(cx.attr_span);
+            cx.expected_list(cx.attr_span, args);
             return reprs;
         };
 
@@ -278,7 +278,7 @@ impl AlignParser {
     fn parse<S: Stage>(&mut self, cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) {
         match args {
             ArgParser::NoArgs | ArgParser::NameValue(_) => {
-                cx.expected_list(cx.attr_span);
+                cx.expected_list(cx.attr_span, args);
             }
             ArgParser::List(list) => {
                 let Some(align) = list.single() else {

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -295,7 +295,7 @@ pub(crate) fn parse_stability<S: Stage>(
     let mut since = None;
 
     let ArgParser::List(list) = args else {
-        cx.expected_list(cx.attr_span);
+        cx.expected_list(cx.attr_span, args);
         return None;
     };
 
@@ -315,11 +315,7 @@ pub(crate) fn parse_stability<S: Stage>(
                 insert_value_into_option_or_error(cx, &param, &mut since, word.unwrap())?
             }
             _ => {
-                cx.emit_err(session_diagnostics::UnknownMetaItem {
-                    span: param_span,
-                    item: param.path().to_string(),
-                    expected: &["feature", "since"],
-                });
+                cx.expected_specific_argument(param_span, &[sym::feature, sym::since]);
                 return None;
             }
         }
@@ -371,7 +367,7 @@ pub(crate) fn parse_unstability<S: Stage>(
     let mut old_name = None;
 
     let ArgParser::List(list) = args else {
-        cx.expected_list(cx.attr_span);
+        cx.expected_list(cx.attr_span, args);
         return None;
     };
 
@@ -426,11 +422,17 @@ pub(crate) fn parse_unstability<S: Stage>(
                 insert_value_into_option_or_error(cx, &param, &mut old_name, word.unwrap())?
             }
             _ => {
-                cx.emit_err(session_diagnostics::UnknownMetaItem {
-                    span: param.span(),
-                    item: param.path().to_string(),
-                    expected: &["feature", "reason", "issue", "soft", "implied_by", "old_name"],
-                });
+                cx.expected_specific_argument(
+                    param.span(),
+                    &[
+                        sym::feature,
+                        sym::reason,
+                        sym::issue,
+                        sym::soft,
+                        sym::implied_by,
+                        sym::old_name,
+                    ],
+                );
                 return None;
             }
         }

compiler/rustc_attr_parsing/src/attributes/traits.rs

@@ -22,7 +22,7 @@ impl<S: Stage> SingleAttributeParser<S> for SkipDuringMethodDispatchParser {
         let mut array = false;
         let mut boxed_slice = false;
         let Some(args) = args.list() else {
-            cx.expected_list(cx.attr_span);
+            cx.expected_list(cx.attr_span, args);
             return None;
         };
         if args.is_empty() {

compiler/rustc_attr_parsing/src/attributes/util.rs

@@ -43,7 +43,7 @@ pub(crate) fn parse_single_integer<S: Stage>(
     args: &ArgParser,
 ) -> Option<u128> {
     let Some(list) = args.list() else {
-        cx.expected_list(cx.attr_span);
+        cx.expected_list(cx.attr_span, args);
         return None;
     };
     let Some(single) = list.single() else {