Rollup of 6 pull requests

compiler/rustc_attr_parsing/src/attributes/autodiff.rs

@@ -36,7 +36,8 @@ impl<S: Stage> SingleAttributeParser<S> for RustcAutodiffParser {
             ArgParser::NoArgs => return Some(AttributeKind::RustcAutodiff(None)),
             ArgParser::List(list) => list,
             ArgParser::NameValue(_) => {
-                cx.expected_list_or_no_args(cx.attr_span);
+                let attr_span = cx.attr_span;
+                cx.adcx().expected_list_or_no_args(attr_span);
                 return None;
             }
         };
@@ -45,23 +46,23 @@ impl<S: Stage> SingleAttributeParser<S> for RustcAutodiffParser {
 
         // Parse name
         let Some(mode) = items.next() else {
-            cx.expected_at_least_one_argument(list.span);
+            cx.adcx().expected_at_least_one_argument(list.span);
             return None;
         };
         let Some(mode) = mode.meta_item() else {
-            cx.expected_identifier(mode.span());
+            cx.adcx().expected_identifier(mode.span());
             return None;
         };
         let Ok(()) = mode.args().no_args() else {
-            cx.expected_identifier(mode.span());
+            cx.adcx().expected_identifier(mode.span());
             return None;
         };
         let Some(mode) = mode.path().word() else {
-            cx.expected_identifier(mode.span());
+            cx.adcx().expected_identifier(mode.span());
             return None;
         };
         let Ok(mode) = DiffMode::from_str(mode.as_str()) else {
-            cx.expected_specific_argument(mode.span, DiffMode::all_modes());
+            cx.adcx().expected_specific_argument(mode.span, DiffMode::all_modes());
             return None;
         };
 
@@ -81,26 +82,29 @@ impl<S: Stage> SingleAttributeParser<S> for RustcAutodiffParser {
         let mut activities = ThinVec::new();
         for activity in items {
             let MetaItemOrLitParser::MetaItemParser(activity) = activity else {
-                cx.expected_specific_argument(activity.span(), DiffActivity::all_activities());
+                cx.adcx()
+                    .expected_specific_argument(activity.span(), DiffActivity::all_activities());
                 return None;
             };
             let Ok(()) = activity.args().no_args() else {
-                cx.expected_specific_argument(activity.span(), DiffActivity::all_activities());
+                cx.adcx()
+                    .expected_specific_argument(activity.span(), DiffActivity::all_activities());
                 return None;
             };
             let Some(activity) = activity.path().word() else {
-                cx.expected_specific_argument(activity.span(), DiffActivity::all_activities());
+                cx.adcx()
+                    .expected_specific_argument(activity.span(), DiffActivity::all_activities());
                 return None;
             };
             let Ok(activity) = DiffActivity::from_str(activity.as_str()) else {
-                cx.expected_specific_argument(activity.span, DiffActivity::all_activities());
+                cx.adcx().expected_specific_argument(activity.span, DiffActivity::all_activities());
                 return None;
             };
 
             activities.push(activity);
         }
         let Some(ret_activity) = activities.pop() else {
-            cx.expected_specific_argument(
+            cx.adcx().expected_specific_argument(
                 list.span.with_lo(list.span.hi()),
                 DiffActivity::all_activities(),
             );

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -44,11 +44,41 @@ pub fn parse_cfg<S: Stage>(
     args: &ArgParser,
 ) -> Option<CfgEntry> {
     let ArgParser::List(list) = args else {
-        cx.expected_list(cx.attr_span, args);
+        let attr_span = cx.attr_span;
+        cx.adcx().expected_list(attr_span, args);
         return None;
     };
+
     let Some(single) = list.single() else {
-        cx.expected_single_argument(list.span);
+        let target = cx.target;
+        let mut adcx = cx.adcx();
+        if list.is_empty() {
+            // `#[cfg()]`
+            let message = format!("if the {target} should be disabled, use `#[cfg(false)]`");
+            adcx.push_suggestion(message, list.span, "(false)".to_string());
+        } else {
+            // `#[cfg(foo, bar)]`
+            if let Ok(args) = adcx
+                .sess()
+                .source_map()
+                .span_to_source(list.span, |src, start, end| Ok(src[start..end].to_string()))
+            {
+                let all = format!("(all{args})");
+                let any = format!("(any{args})");
+
+                let all_msg = format!(
+                    "if the {target} should be enabled when all these predicates are, wrap them in `all`"
+                );
+                let any_msg = format!(
+                    "alternately, if the {target} should be enabled when any of these predicates are, wrap them in `any`"
+                );
+
+                adcx.push_suggestion(all_msg, list.span, all);
+                adcx.push_suggestion(any_msg, list.span, any);
+            }
+        }
+
+        adcx.expected_single_argument(list.span);
         return None;
     };
     parse_cfg_entry(cx, single).ok()
@@ -63,7 +93,7 @@ pub fn parse_cfg_entry<S: Stage>(
             ArgParser::List(list) => match meta.path().word_sym() {
                 Some(sym::not) => {
                     let Some(single) = list.single() else {
-                        return Err(cx.expected_single_argument(list.span));
+                        return Err(cx.adcx().expected_single_argument(list.span));
                     };
                     CfgEntry::Not(Box::new(parse_cfg_entry(cx, single)?), list.span)
                 }
@@ -87,14 +117,14 @@ pub fn parse_cfg_entry<S: Stage>(
             a @ (ArgParser::NoArgs | ArgParser::NameValue(_)) => {
                 let Some(name) = meta.path().word_sym().filter(|s| !s.is_path_segment_keyword())
                 else {
-                    return Err(cx.expected_identifier(meta.path().span()));
+                    return Err(cx.adcx().expected_identifier(meta.path().span()));
                 };
                 parse_name_value(name, meta.path().span(), a.name_value(), meta.span(), cx)?
             }
         },
         MetaItemOrLitParser::Lit(lit) => match lit.kind {
             LitKind::Bool(b) => CfgEntry::Bool(b, lit.span),
-            _ => return Err(cx.expected_identifier(lit.span)),
+            _ => return Err(cx.adcx().expected_identifier(lit.span)),
         },
     })
 }
@@ -152,17 +182,17 @@ fn parse_cfg_entry_target<S: Stage>(
     for sub_item in list.mixed() {
         // First, validate that this is a NameValue item
         let Some(sub_item) = sub_item.meta_item() else {
-            cx.expected_name_value(sub_item.span(), None);
+            cx.adcx().expected_name_value(sub_item.span(), None);
             continue;
         };
         let Some(nv) = sub_item.args().name_value() else {
-            cx.expected_name_value(sub_item.span(), None);
+            cx.adcx().expected_name_value(sub_item.span(), None);
             continue;
         };
 
         // Then, parse it as a name-value item
         let Some(name) = sub_item.path().word_sym().filter(|s| !s.is_path_segment_keyword()) else {
-            return Err(cx.expected_identifier(sub_item.path().span()));
+            return Err(cx.adcx().expected_identifier(sub_item.path().span()));
         };
         let name = Symbol::intern(&format!("target_{name}"));
         if let Ok(cfg) =
@@ -187,9 +217,9 @@ pub(crate) fn parse_name_value<S: Stage>(
         None => None,
         Some(value) => {
             let Some(value_str) = value.value_as_str() else {
-                return Err(
-                    cx.expected_string_literal(value.value_span, Some(value.value_as_lit()))
-                );
+                return Err(cx
+                    .adcx()
+                    .expected_string_literal(value.value_span, Some(value.value_as_lit())));
             };
             Some((value_str, value.value_span))
         }
@@ -335,8 +365,10 @@ pub fn parse_cfg_attr(
                 path: AttrPath::from_ast(&cfg_attr.get_normal_item().path, identity),
                 description: ParsedDescription::Attribute,
                 reason,
-                suggestions: CFG_ATTR_TEMPLATE
-                    .suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
+                suggestions: session_diagnostics::AttributeParseErrorSuggestions::CreatedByTemplate(
+                    CFG_ATTR_TEMPLATE
+                        .suggestions(AttrSuggestionStyle::Attribute(cfg_attr.style), sym::cfg_attr),
+                ),
             });
         }
     }

compiler/rustc_attr_parsing/src/attributes/cfi_encoding.rs

@@ -13,17 +13,18 @@ impl<S: Stage> SingleAttributeParser<S> for CfiEncodingParser {
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
         let Some(name_value) = args.name_value() else {
-            cx.expected_name_value(cx.attr_span, Some(sym::cfi_encoding));
+            let attr_span = cx.attr_span;
+            cx.adcx().expected_name_value(attr_span, Some(sym::cfi_encoding));
             return None;
         };
 
         let Some(value_str) = name_value.value_as_str() else {
-            cx.expected_string_literal(name_value.value_span, None);
+            cx.adcx().expected_string_literal(name_value.value_span, None);
             return None;
         };
 
         if value_str.as_str().trim().is_empty() {
-            cx.expected_non_empty_string_literal(name_value.value_span);
+            cx.adcx().expected_non_empty_string_literal(name_value.value_span);
             return None;
         }