Rollup of 13 pull requests

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -10,7 +10,7 @@ use crate::attributes::AttributeSafety;
 use crate::session_diagnostics::{
     EmptyExportName, NakedFunctionIncompatibleAttribute, NullOnExport, NullOnObjcClass,
     NullOnObjcSelector, ObjcClassExpectedStringLiteral, ObjcSelectorExpectedStringLiteral,
-    SanitizeInvalidStatic,
+    SanitizeInvalidStatic, TargetFeatureOnLangItem,
 };
 use crate::target_checking::Policy::AllowSilent;
 
@@ -524,15 +524,6 @@ impl CombineAttributeParser for TargetFeatureParser {
         was_forced: false,
     };
     const TEMPLATE: AttributeTemplate = template!(List: &["enable = \"feat1, feat2\""]);
-    const STABILITY: AttributeStability = AttributeStability::Stable;
-
-    fn extend(
-        cx: &mut AcceptContext<'_, '_>,
-        args: &ArgParser,
-    ) -> impl IntoIterator<Item = Self::Item> {
-        parse_tf_attribute(cx, args)
-    }
-
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
         Allow(Target::Method(MethodKind::Inherent)),
@@ -544,6 +535,29 @@ impl CombineAttributeParser for TargetFeatureParser {
         Warn(Target::MacroDef),
         Warn(Target::MacroCall),
     ]);
+    const STABILITY: AttributeStability = AttributeStability::Stable;
+
+    fn extend(
+        cx: &mut AcceptContext<'_, '_>,
+        args: &ArgParser,
+    ) -> impl IntoIterator<Item = Self::Item> {
+        parse_tf_attribute(cx, args)
+    }
+
+    fn finalize_check(cx: &FinalizeContext<'_, '_>, attr_span: Span) {
+        // `#[target_feature]` is incompatible with lang item functions,
+        // except on WASM where calling target-feature functions is safe (see #84988).
+        if !cx.sess().target.is_like_wasm && !cx.sess().opts.actually_rustdoc {
+            // `#[panic_handler]` is checked first so it takes priority in the diagnostic.
+            let lang_kind = cx
+                .all_attrs
+                .iter()
+                .find_map(|a| [sym::panic_handler, sym::lang].into_iter().find(|&s| a.word_is(s)));
+            if let Some(kind) = lang_kind {
+                cx.emit_err(TargetFeatureOnLangItem { attr_span, kind, item_span: cx.target_span });
+            }
+        }
+    }
 }
 
 pub(crate) struct ForceTargetFeatureParser;

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -1,25 +1,29 @@
 use rustc_ast::ast::{AttrStyle, LitKind, MetaItemLit};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, IndexEntry};
 use rustc_errors::{Applicability, msg};
 use rustc_feature::AttributeStability;
 use rustc_hir::Target;
 use rustc_hir::attrs::{
-    AttributeKind, CfgEntry, CfgHideShow, CfgInfo, DocAttribute, DocInline, HideOrShow,
+    AttributeKind, CfgEntry, CfgHideShow, DocAttribute, DocCfgHideShow, DocCfgHideShowValue,
+    DocInline, HideOrShow,
 };
 use rustc_session::errors::feature_err;
 use rustc_span::{Span, Symbol, edition, sym};
-use thin_vec::ThinVec;
 
 use super::prelude::{ALL_TARGETS, AllowedTargets};
 use super::{AcceptMapping, AttributeParser, template};
 use crate::context::{AcceptContext, FinalizeContext};
 use crate::diagnostics::{
     AttrCrateLevelOnly, DocAliasDuplicated, DocAutoCfgExpectsHideOrShow,
-    DocAutoCfgHideShowExpectsList, DocAutoCfgHideShowUnexpectedItem, DocAutoCfgWrongLiteral,
-    DocTestLiteral, DocTestTakesList, DocTestUnknown, DocUnknownAny, DocUnknownInclude,
-    DocUnknownPasses, DocUnknownPlugins, DocUnknownSpotlight, ExpectedNameValue, ExpectedNoArgs,
-    IllFormedAttributeInput, MalformedDoc,
+    DocAutoCfgHideShowExpectsList, DocAutoCfgHideShowNoIdentBeforeValues,
+    DocAutoCfgHideShowUnexpectedItem, DocAutoCfgHideShowUnexpectedItemAfterValues,
+    DocAutoCfgHideShowValuesMix, DocAutoCfgWrongLiteral, DocTestLiteral, DocTestTakesList,
+    DocTestUnknown, DocUnknownAny, DocUnknownInclude, DocUnknownPasses, DocUnknownPlugins,
+    DocUnknownSpotlight, ExpectedNameValue, ExpectedNoArgs, IllFormedAttributeInput, MalformedDoc,
+};
+use crate::parser::{
+    ArgParser, MetaItemListParser, MetaItemOrLitParser, MetaItemParser, OwnedPathParser,
 };
-use crate::parser::{ArgParser, MetaItemOrLitParser, MetaItemParser, OwnedPathParser};
 use crate::session_diagnostics::{
     DocAliasBadChar, DocAliasEmpty, DocAliasMalformed, DocAliasStartEnd, DocAttrNotCrateLevel,
     DocAttributeNotAttribute, DocKeywordNotKeyword, UnusedDuplicate,
@@ -304,6 +308,81 @@ impl DocParser {
         }
     }
 
+    // Parses the `doc(auto_cfg(hide/show(..., values())))` attribute.
+    fn parse_auto_cfg_values(
+        &self,
+        cx: &mut AcceptContext<'_, '_>,
+        list: &MetaItemListParser,
+        values: &mut Option<DocCfgHideShow>,
+    ) {
+        let mut cfg_values = DocCfgHideShow::new();
+
+        let mut values_set = FxHashSet::default();
+        for item in list.mixed() {
+            match item {
+                // If it's a string literal, all good.
+                MetaItemOrLitParser::Lit(MetaItemLit {
+                    kind: LitKind::Str(symbol, _),
+                    span,
+                    ..
+                }) => match &mut cfg_values {
+                    DocCfgHideShow::Any(any_span) => {
+                        cx.emit_lint(
+                            rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
+                            DocAutoCfgHideShowValuesMix { value_span: *span },
+                            *any_span,
+                        );
+                    }
+                    DocCfgHideShow::List(symbols) => {
+                        if values_set.insert(symbol) {
+                            symbols.push(DocCfgHideShowValue::new(*symbol, *span));
+                        }
+                    }
+                },
+                // If it's any other kind of literal, then it's wrong and we emit a lint.
+                MetaItemOrLitParser::Lit(lit) => cx.emit_lint(
+                    rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
+                    DocAutoCfgHideShowUnexpectedItem { attr_name: lit.symbol },
+                    lit.span,
+                ),
+                // If it's a list, then only `any()` and `none()` are allowed and they must not
+                // contain any item.
+                MetaItemOrLitParser::MetaItemParser(sub_item) => {
+                    if let Some(ident) = sub_item.ident()
+                        && [sym::any, sym::none].contains(&ident.name)
+                        && let ArgParser::List(list) = sub_item.args()
+                        && list.mixed().count() == 0
+                    {
+                        if ident.name == sym::any {
+                            if let DocCfgHideShow::List(values) = &cfg_values
+                                && let Some(value) = values.first()
+                            {
+                                cx.emit_lint(
+                                    rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
+                                    DocAutoCfgHideShowValuesMix { value_span: value.span },
+                                    sub_item.span(),
+                                );
+                            } else {
+                                cfg_values.merge_with(&DocCfgHideShow::Any(sub_item.span()));
+                            }
+                        } else {
+                            cfg_values.push_none(sub_item.span());
+                        }
+                    } else {
+                        cx.emit_lint(
+                            rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
+                            DocAutoCfgHideShowUnexpectedItem {
+                                attr_name: sub_item.ident().unwrap().name,
+                            },
+                            sub_item.span(),
+                        );
+                    }
+                }
+            }
+        }
+        *values = Some(cfg_values);
+    }
+
     fn parse_auto_cfg(
         &mut self,
         cx: &mut AcceptContext<'_, '_>,
@@ -315,7 +394,7 @@ impl DocParser {
                 self.attribute.auto_cfg_change.push((true, path.span()));
             }
             ArgParser::List(list) => {
-                for meta in list.mixed() {
+                'main: for meta in list.mixed() {
                     let MetaItemOrLitParser::MetaItemParser(item) = meta else {
                         cx.emit_lint(
                             rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
@@ -324,6 +403,8 @@ impl DocParser {
                         );
                         continue;
                     };
+                    // Only `hide` and `show` are allowed in `auto_cfg` if it's a list, and both
+                    // must be a list.
                     let (kind, attr_name) = match item.path().word_sym() {
                         Some(sym::hide) => (HideOrShow::Hide, sym::hide),
                         Some(sym::show) => (HideOrShow::Show, sym::show),
@@ -345,56 +426,71 @@ impl DocParser {
                         continue;
                     };
 
-                    let mut cfg_hide_show = CfgHideShow { kind, values: ThinVec::new() };
+                    let mut cfg_hide_show = CfgHideShow { kind, values: FxIndexMap::default() };
 
+                    let mut cfg_names = FxHashSet::default();
+                    let mut values = None;
                     for item in list.mixed() {
                         let MetaItemOrLitParser::MetaItemParser(sub_item) = item else {
                             cx.emit_lint(
                                 rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
                                 DocAutoCfgHideShowUnexpectedItem { attr_name },
                                 item.span(),
                             );
-                            continue;
+                            continue 'main;
                         };
                         match sub_item.args() {
-                            a @ (ArgParser::NoArgs | ArgParser::NameValue(_)) => {
+                            ArgParser::NoArgs if values.is_none() => {
                                 let Some(name) = sub_item.path().word_sym() else {
-                                    // FIXME: remove this method once merged and uncomment the line
-                                    // below instead.
-                                    // cx.expected_identifier(sub_item.path().span());
+                                    cx.adcx().expected_identifier(sub_item.path().span());
+                                    continue 'main;
+                                };
+                                cfg_names.insert(name);
+                            }
+                            // The only accepted list is `values()`.
+                            ArgParser::List(list) if values.is_none() => {
+                                let Some(sym::values) = sub_item.path().word_sym() else {
+                                    cx.adcx().expected_identifier(sub_item.path().span());
+                                    continue 'main;
+                                };
+                                if cfg_names.is_empty() {
                                     cx.emit_lint(
                                         rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
-                                        MalformedDoc,
-                                        sub_item.path().span(),
-                                    );
-                                    continue;
-                                };
-                                if let Ok(CfgEntry::NameValue { name, value, .. }) =
-                                    super::cfg::parse_name_value(
-                                        name,
-                                        sub_item.path().span(),
-                                        a.as_name_value(),
+                                        DocAutoCfgHideShowNoIdentBeforeValues,
                                         sub_item.span(),
-                                        cx,
-                                    )
-                                {
-                                    cfg_hide_show.values.push(CfgInfo {
-                                        name,
-                                        name_span: sub_item.path().span(),
-                                        // If `value` is `Some`, `a.name_value()` will always return
-                                        // `Some` as well.
-                                        value: value
-                                            .map(|v| (v, a.as_name_value().unwrap().value_span)),
-                                    })
+                                    );
+                                    continue 'main;
                                 }
+                                self.parse_auto_cfg_values(cx, list, &mut values);
                             }
-                            _ => {
+                            // No `name = value` is allowed.
+                            ArgParser::NameValue(_) => {
                                 cx.emit_lint(
                                     rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
                                     DocAutoCfgHideShowUnexpectedItem { attr_name },
                                     sub_item.span(),
                                 );
-                                continue;
+                            }
+                            // If `values()` was already used, no item should come after it.
+                            _ => {
+                                cx.emit_lint(
+                                    rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
+                                    DocAutoCfgHideShowUnexpectedItemAfterValues,
+                                    sub_item.span(),
+                                );
+                            }
+                        }
+                    }
+
+                    let values = values.unwrap_or(DocCfgHideShow::new_with_only_key(item.span()));
+                    #[allow(rustc::potential_query_instability)]
+                    for cfg_name in &cfg_names {
+                        match cfg_hide_show.values.entry(*cfg_name) {
+                            IndexEntry::Vacant(v) => {
+                                v.insert(values.clone());
+                            }
+                            IndexEntry::Occupied(mut o) => {
+                                o.get_mut().merge_with(&values);
                             }
                         }
                     }

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -576,7 +576,7 @@ impl NoArgsAttributeParser for FfiPureParser {
     const STABILITY: AttributeStability = unstable!(ffi_pure);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiPure;
 
-    fn finalize_check(attr_span: Span, cx: &FinalizeContext<'_, '_>) {
+    fn finalize_check(cx: &FinalizeContext<'_, '_>, attr_span: Span) {
         // `#[ffi_const]` functions cannot be `#[ffi_pure]`.
         if cx.all_attrs.iter().any(|a| a.word_is(sym::ffi_const)) {
             cx.emit_err(BothFfiConstAndPure { attr_span });

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -154,7 +154,7 @@ pub(crate) trait SingleAttributeParser: 'static {
     /// reject incompatible combinations. `attr_span` is the span of this attribute.
     ///
     /// Defaults to a no-op.
-    fn finalize_check(_attr_span: Span, _cx: &FinalizeContext<'_, '_>) {}
+    fn finalize_check(_cx: &FinalizeContext<'_, '_>, _attr_span: Span) {}
 }
 
 /// Use in combination with [`SingleAttributeParser`].
@@ -187,7 +187,7 @@ impl<T: SingleAttributeParser> AttributeParser for Single<T> {
 
     fn finalize(self, cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
         let (kind, span) = self.1?;
-        T::finalize_check(span, cx);
+        T::finalize_check(cx, span);
         Some(kind)
     }
 }
@@ -275,7 +275,7 @@ pub(crate) trait NoArgsAttributeParser: 'static {
     /// `attr_span` is the span of this attribute.
     ///
     /// Defaults to a no-op.
-    fn finalize_check(_attr_span: Span, _cx: &FinalizeContext<'_, '_>) {}
+    fn finalize_check(_cx: &FinalizeContext<'_, '_>, _attr_span: Span) {}
 }
 
 pub(crate) struct WithoutArgs<T: NoArgsAttributeParser>(PhantomData<T>);
@@ -299,8 +299,8 @@ impl<T: NoArgsAttributeParser> SingleAttributeParser for WithoutArgs<T> {
         Some(T::CREATE(cx.attr_span))
     }
 
-    fn finalize_check(attr_span: Span, cx: &FinalizeContext<'_, '_>) {
-        T::finalize_check(attr_span, cx)
+    fn finalize_check(cx: &FinalizeContext<'_, '_>, attr_span: Span) {
+        T::finalize_check(cx, attr_span)
     }
 }
 
@@ -335,6 +335,14 @@ pub(crate) trait CombineAttributeParser: 'static {
         cx: &mut AcceptContext<'_, '_>,
         args: &ArgParser,
     ) -> impl IntoIterator<Item = Self::Item>;
+
+    /// Optional cross-attribute validation, run once during finalization after all
+    /// attributes on the item have been parsed. Has access to the sibling attributes via
+    /// [`FinalizeContext::all_attrs`], so it can reject incompatible combinations.
+    /// `attr_span` is the span of the first attribute that was encountered.
+    ///
+    /// Defaults to a no-op.
+    fn finalize_check(_cx: &FinalizeContext<'_, '_>, _attr_span: Span) {}
 }
 
 /// Use in combination with [`CombineAttributeParser`].
@@ -367,8 +375,9 @@ impl<T: CombineAttributeParser> AttributeParser for Combine<T> {
     const ALLOWED_TARGETS: AllowedTargets<'_> = T::ALLOWED_TARGETS;
     const SAFETY: AttributeSafety = T::SAFETY;
 
-    fn finalize(self, _cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
+    fn finalize(self, cx: &FinalizeContext<'_, '_>) -> Option<AttributeKind> {
         if let Some(first_span) = self.first_span {
+            T::finalize_check(cx, first_span);
             Some(T::CONVERT(self.items, first_span))
         } else {
             None