rustdoc: support multiple stability attributes

Author: dianne

compiler/rustc_attr/src/builtin.rs

@@ -89,6 +89,10 @@ impl Stability {
     pub fn unstable_features(&self) -> impl Iterator<Item = Symbol> + use<'_> {
         self.level.unstable_features()
     }
+
+    pub fn is_rustc_private(&self) -> bool {
+        self.level.has_unstable_feature(sym::rustc_private)
+    }
 }
 
 /// Represents the `#[rustc_const_unstable]` and `#[rustc_const_stable]` attributes.

src/librustdoc/clean/inline.rs

@@ -432,10 +432,8 @@ pub(crate) fn build_impl(
     let associated_trait = tcx.impl_trait_ref(did).map(ty::EarlyBinder::skip_binder);
 
     // Do not inline compiler-internal items unless we're a compiler-internal crate.
-    let is_compiler_internal = |did| {
-        tcx.lookup_stability(did)
-            .is_some_and(|stab| stab.is_unstable() && stab.feature == sym::rustc_private)
-    };
+    let is_compiler_internal =
+        |did| tcx.lookup_stability(did).is_some_and(|stab| stab.is_rustc_private());
     let document_compiler_internal = is_compiler_internal(LOCAL_CRATE.as_def_id());
     let is_directly_public = |cx: &mut DocContext<'_>, did| {
         cx.cache.effective_visibilities.is_directly_public(tcx, did)

src/librustdoc/clean/types.rs

@@ -385,8 +385,8 @@ impl Item {
     /// Returns the effective stability of the item.
     ///
     /// This method should only be called after the `propagate-stability` pass has been run.
-    pub(crate) fn stability(&self, tcx: TyCtxt<'_>) -> Option<Stability> {
-        let stability = self.inner.stability;
+    pub(crate) fn stability(&self, tcx: TyCtxt<'_>) -> Option<&Stability> {
+        let stability = self.inner.stability.as_ref();
         debug_assert!(
             stability.is_some()
                 || self.def_id().is_none_or(|did| tcx.lookup_stability(did).is_none()),
@@ -395,7 +395,7 @@ impl Item {
         stability
     }
 
-    pub(crate) fn const_stability(&self, tcx: TyCtxt<'_>) -> Option<ConstStability> {
+    pub(crate) fn const_stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<&'tcx ConstStability> {
         self.def_id().and_then(|did| tcx.lookup_const_stability(did))
     }
 

src/librustdoc/html/format.rs

@@ -1649,7 +1649,7 @@ impl PrintWithSpace for hir::Mutability {
 pub(crate) fn print_constness_with_space(
     c: &hir::Constness,
     overall_stab: Option<StableSince>,
-    const_stab: Option<ConstStability>,
+    const_stab: Option<&ConstStability>,
 ) -> &'static str {
     match c {
         hir::Constness::Const => match (overall_stab, const_stab) {

src/librustdoc/html/render/mod.rs

@@ -53,7 +53,7 @@ use rustc_hir::def_id::{DefId, DefIdSet};
 use rustc_middle::ty::print::PrintTraitRefExt;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::RustcVersion;
-use rustc_span::symbol::{Symbol, sym};
+use rustc_span::symbol::Symbol;
 use rustc_span::{BytePos, DUMMY_SP, FileName, RealFileName};
 use serde::ser::SerializeMap;
 use serde::{Serialize, Serializer};
@@ -675,17 +675,23 @@ enum ShortItemInfo {
     Deprecation {
         message: String,
     },
-    /// The feature corresponding to an unstable item, and optionally
-    /// a tracking issue URL and number.
+    /// The features corresponding to an unstable item, and optionally
+    /// a tracking issue URL and number for each.
     Unstable {
-        feature: String,
-        tracking: Option<(String, u32)>,
+        features: Vec<UnstableFeature>,
     },
     Portability {
         message: String,
     },
 }
 
+#[derive(Template)]
+#[template(path = "unstable_feature.html")]
+struct UnstableFeature {
+    feature: String,
+    tracking: Option<(String, u32)>,
+}
+
 /// Render the stability, deprecation and portability information that is displayed at the top of
 /// the item's documentation.
 fn short_item_info(
@@ -724,19 +730,24 @@ fn short_item_info(
 
     // Render unstable items. But don't render "rustc_private" crates (internal compiler crates).
     // Those crates are permanently unstable so it makes no sense to render "unstable" everywhere.
-    if let Some((StabilityLevel::Unstable { reason: _, issue, .. }, feature)) = item
+    if let Some(StabilityLevel::Unstable { unstables, .. }) = item
         .stability(cx.tcx())
         .as_ref()
-        .filter(|stab| stab.feature != sym::rustc_private)
-        .map(|stab| (stab.level, stab.feature))
+        .filter(|stab| !stab.is_rustc_private())
+        .map(|stab| &stab.level)
     {
-        let tracking = if let (Some(url), Some(issue)) = (&cx.shared.issue_tracker_base_url, issue)
-        {
-            Some((url.clone(), issue.get()))
-        } else {
-            None
+        let track = |issue: Option<std::num::NonZero<u32>>| {
+            if let (Some(url), Some(issue)) = (&cx.shared.issue_tracker_base_url, issue) {
+                Some((url.clone(), issue.get()))
+            } else {
+                None
+            }
         };
-        extra_info.push(ShortItemInfo::Unstable { feature: feature.to_string(), tracking });
+        let features = unstables
+            .iter()
+            .map(|u| UnstableFeature { feature: u.feature.to_string(), tracking: track(u.issue) })
+            .collect();
+        extra_info.push(ShortItemInfo::Unstable { features });
     }
 
     if let Some(message) = portability(item, parent) {
@@ -990,7 +1001,7 @@ fn assoc_method(
 fn render_stability_since_raw_with_extra(
     w: &mut Buffer,
     stable_version: Option<StableSince>,
-    const_stability: Option<ConstStability>,
+    const_stability: Option<&ConstStability>,
     extra_class: &str,
 ) -> bool {
     let mut title = String::new();
@@ -1006,12 +1017,16 @@ fn render_stability_since_raw_with_extra(
             since_to_string(&since)
                 .map(|since| (format!("const since {since}"), format!("const: {since}")))
         }
-        Some(ConstStability { level: StabilityLevel::Unstable { issue, .. }, feature, .. }) => {
+        Some(ConstStability { level: StabilityLevel::Unstable { unstables, .. }, .. }) => {
             if stable_version.is_none() {
                 // don't display const unstable if entirely unstable
                 None
             } else {
-                let unstable = if let Some(n) = issue {
+                // if constness depends on multiple unstable features, only link to the first
+                // tracking issue found, to save space. the issue description should link to issues
+                // for any features it can intersect with
+                let feature_issue = unstables.iter().find_map(|u| u.issue.map(|n| (u.feature, n)));
+                let unstable = if let Some((feature, n)) = feature_issue {
                     format!(
                         "<a \
                         href=\"https://github.com/rust-lang/rust/issues/{n}\" \
@@ -1061,7 +1076,7 @@ fn since_to_string(since: &StableSince) -> Option<String> {
 fn render_stability_since_raw(
     w: &mut Buffer,
     ver: Option<StableSince>,
-    const_stability: Option<ConstStability>,
+    const_stability: Option<&ConstStability>,
 ) -> bool {
     render_stability_since_raw_with_extra(w, ver, const_stability, "")
 }

src/librustdoc/html/render/print_item.rs

@@ -14,7 +14,7 @@ use rustc_hir::def_id::DefId;
 use rustc_index::IndexVec;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::hygiene::MacroKind;
-use rustc_span::symbol::{Symbol, kw, sym};
+use rustc_span::symbol::{Symbol, kw};
 use tracing::{debug, info};
 
 use super::type_layout::document_type_layout;
@@ -567,7 +567,7 @@ fn extra_info_tags<'a, 'tcx: 'a>(
         // to render "unstable" everywhere.
         let stability = import_def_id
             .map_or_else(|| item.stability(tcx), |import_did| tcx.lookup_stability(import_did));
-        if stability.is_some_and(|s| s.is_unstable() && s.feature != sym::rustc_private) {
+        if stability.is_some_and(|s| s.is_unstable() && !s.is_rustc_private()) {
             write!(f, "{}", tag_html("unstable", "", "Experimental"))?;
         }
 

src/librustdoc/html/templates/short_item_info.html

@@ -4,18 +4,11 @@
             <span class="emoji">👎</span> {# #}
             <span>{{message|safe}}</span> {# #}
         </div>
-    {% when Self::Unstable with { feature, tracking } %}
+    {% when Self::Unstable with { features } %}
         <div class="stab unstable"> {# #}
             <span class="emoji">🔬</span> {# #}
             <span> {# #}
-                This is a nightly-only experimental API. ({# #}
-                <code>{{feature}}</code>
-                {% match tracking %}
-                    {% when Some with ((url, num)) %}
-                        &nbsp;<a href="{{url}}{{num}}">#{{num}}</a>
-                    {% when None %}
-                {% endmatch %}
-                ) {# #}
+                This is a nightly-only experimental API. ({{features|join(", ")|safe}}) {# #}
             </span> {# #}
         </div>
     {% when Self::Portability with { message } %}

src/librustdoc/html/templates/unstable_feature.html

@@ -0,0 +1,6 @@
+<code>{{feature}}</code>
+{% match tracking %}
+    {% when Some with ((url, num)) %}
+        &nbsp;<a href="{{url}}{{num}}">#{{num}}</a>
+    {% when None %}
+{% endmatch %}

src/librustdoc/passes/propagate_stability.rs

@@ -26,7 +26,7 @@ pub(crate) fn propagate_stability(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
 }
 
 struct StabilityPropagator<'a, 'tcx> {
-    parent_stability: Option<Stability>,
+    parent_stability: Option<&'tcx Stability>,
     cx: &'a mut DocContext<'tcx>,
 }
 
@@ -85,7 +85,7 @@ impl<'a, 'tcx> DocFolder for StabilityPropagator<'a, 'tcx> {
             }
         };
 
-        item.inner.stability = stability;
+        item.inner.stability = stability.cloned();
         self.parent_stability = stability;
         let item = self.fold_item_recur(item);
         self.parent_stability = parent_stability;
@@ -94,13 +94,13 @@ impl<'a, 'tcx> DocFolder for StabilityPropagator<'a, 'tcx> {
     }
 }
 
-fn merge_stability(
-    own_stability: Option<Stability>,
-    parent_stability: Option<Stability>,
-) -> Option<Stability> {
+fn merge_stability<'tcx>(
+    own_stability: Option<&'tcx Stability>,
+    parent_stability: Option<&'tcx Stability>,
+) -> Option<&'tcx Stability> {
     if let Some(own_stab) = own_stability
-        && let StabilityLevel::Stable { since: own_since, allowed_through_unstable_modules: false } =
-            own_stab.level
+        && let &StabilityLevel::Stable { since: own_since, allowed_through_unstable_modules: false } =
+            &own_stab.level
         && let Some(parent_stab) = parent_stability
         && (parent_stab.is_unstable()
             || parent_stab.stable_since().is_some_and(|parent_since| parent_since > own_since))

tests/rustdoc/stability.rs

@@ -169,3 +169,11 @@ mod prim_i32 {}
 /// We currently don't document stability for keywords, but let's test it anyway.
 #[stable(feature = "rust1", since = "1.0.0")]
 mod if_keyword {}
+
+#[unstable(feature = "test", issue = "none")]
+#[unstable(feature = "test2", issue = "none")]
+pub trait UnstableTraitWithMultipleFeatures {
+    //@ has stability/trait.UnstableTraitWithMultipleFeatures.html \
+    //      '//span[@class="item-info"]//div[@class="stab unstable"]' \
+    //      'This is a nightly-only experimental API. (test, test2)'
+}