rustdoc: report all unstable features needed for items

Author: dianne

src/librustdoc/passes/propagate_stability.rs

@@ -21,19 +21,17 @@ pub(crate) const PROPAGATE_STABILITY: Pass = Pass {
 };
 
 pub(crate) fn propagate_stability(cr: Crate, cx: &mut DocContext<'_>) -> Crate {
-    let crate_stability = cx.tcx.lookup_stability(CRATE_DEF_ID);
+    let crate_stability = cx.tcx.lookup_stability(CRATE_DEF_ID).cloned();
     StabilityPropagator { parent_stability: crate_stability, cx }.fold_crate(cr)
 }
 
 struct StabilityPropagator<'a, 'tcx> {
-    parent_stability: Option<&'tcx Stability>,
+    parent_stability: Option<Stability>,
     cx: &'a mut DocContext<'tcx>,
 }
 
 impl<'a, 'tcx> DocFolder for StabilityPropagator<'a, 'tcx> {
     fn fold_item(&mut self, mut item: Item) -> Option<Item> {
-        let parent_stability = self.parent_stability;
-
         let stability = match item.item_id {
             ItemId::DefId(def_id) => {
                 let own_stability = self.cx.tcx.lookup_stability(def_id);
@@ -59,9 +57,7 @@ impl<'a, 'tcx> DocFolder for StabilityPropagator<'a, 'tcx> {
                     | ItemKind::MacroItem(..)
                     | ItemKind::ProcMacroItem(..)
                     | ItemKind::ConstantItem(..) => {
-                        // If any of the item's parents was stabilized later or is still unstable,
-                        // then use the parent's stability instead.
-                        merge_stability(own_stability, parent_stability)
+                        merge_stability(own_stability, self.parent_stability.as_ref())
                     }
 
                     // Don't inherit the parent's stability for these items, because they
@@ -74,7 +70,7 @@ impl<'a, 'tcx> DocFolder for StabilityPropagator<'a, 'tcx> {
                     | ItemKind::TyAssocTypeItem(..)
                     | ItemKind::AssocTypeItem(..)
                     | ItemKind::PrimitiveItem(..)
-                    | ItemKind::KeywordItem => own_stability,
+                    | ItemKind::KeywordItem => own_stability.cloned(),
 
                     ItemKind::StrippedItem(..) => unreachable!(),
                 }
@@ -85,28 +81,53 @@ impl<'a, 'tcx> DocFolder for StabilityPropagator<'a, 'tcx> {
             }
         };
 
-        item.inner.stability = stability.cloned();
-        self.parent_stability = stability;
+        item.inner.stability = stability.clone();
+        let parent_stability = std::mem::replace(&mut self.parent_stability, stability);
         let item = self.fold_item_recur(item);
         self.parent_stability = parent_stability;
 
         Some(item)
     }
 }
 
-fn merge_stability<'tcx>(
-    own_stability: Option<&'tcx Stability>,
-    parent_stability: Option<&'tcx Stability>,
-) -> Option<&'tcx Stability> {
+fn merge_stability(
+    own_stability: Option<&Stability>,
+    parent_stability: Option<&Stability>,
+) -> Option<Stability> {
     if let Some(own_stab) = own_stability
-        && 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))
     {
-        parent_stability
+        match own_stab.level {
+            // If any of a stable item's parents were stabilized later or are still unstable,
+            // then use the parent's stability instead.
+            StabilityLevel::Stable {
+                since: own_since,
+                allowed_through_unstable_modules: false,
+                ..
+            } if parent_stab.is_unstable()
+                || parent_stab
+                    .stable_since()
+                    .is_some_and(|parent_since| parent_since > own_since) =>
+            {
+                parent_stability.cloned()
+            }
+
+            // If any of an unstable item's parents depend on other unstable features,
+            // then use those as well.
+            StabilityLevel::Unstable { unstables: ref own_gates, reason, is_soft }
+                if let StabilityLevel::Unstable { unstables: parent_gates, .. } =
+                    &parent_stab.level =>
+            {
+                let missing_unstables = parent_gates
+                    .iter()
+                    .filter(|p| !own_gates.iter().any(|u| u.feature == p.feature));
+                let unstables = own_gates.iter().chain(missing_unstables).cloned().collect();
+                Some(Stability { level: StabilityLevel::Unstable { unstables, reason, is_soft } })
+            }
+
+            _ => own_stability.cloned(),
+        }
     } else {
-        own_stability
+        own_stability.cloned()
     }
 }

tests/rustdoc/stability.rs

@@ -55,6 +55,12 @@ pub mod unstable {
         #[stable(feature = "rust1", since = "1.0.0")]
         pub fn foo() {}
     }
+
+    //@ has stability/unstable/fn.nested_unstable.html \
+    //      '//span[@class="item-info"]//div[@class="stab unstable"]' \
+    //      'This is a nightly-only experimental API. (test, unstable)'
+    #[unstable(feature = "test", issue = "none")]
+    pub fn nested_unstable() {}
 }
 
 #[unstable(feature = "unstable", issue = "none")]