Refactor stability structs

This moves stability structs' `feature` fields into
`StabilityLevel::Unstable` and `ConstStabilityLevel::Unstable`, in
preparation to support multiple unstable attributes on items.

Seemingly, the `feature` field isn't used with the
`StabilityLevel::Stable` variant, so I haven't included it.
`rustc_passes::lib_features` uses the 'feature' meta-item for 'stable'
attributes, but it extracts them itself, rather than relying on
`rustc_attr`.

Author: dianne

compiler/rustc_attr/src/builtin.rs

@@ -70,7 +70,6 @@ pub enum OptimizeAttr {
 #[derive(HashStable_Generic)]
 pub struct Stability {
     pub level: StabilityLevel,
-    pub feature: Symbol,
 }
 
 impl Stability {
@@ -88,11 +87,11 @@ impl Stability {
 }
 
 /// Represents the `#[rustc_const_unstable]` and `#[rustc_const_stable]` attributes.
+/// For details see [the dev guide](https://rustc-dev-guide.rust-lang.org/stability.html#rustc_const_unstable).
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[derive(HashStable_Generic)]
 pub struct ConstStability {
     pub level: StabilityLevel,
-    pub feature: Symbol,
     /// This is true iff the `const_stable_indirect` attribute is present.
     pub const_stable_indirect: bool,
     /// whether the function has a `#[rustc_promotable]` attribute
@@ -114,7 +113,6 @@ impl ConstStability {
 #[derive(HashStable_Generic)]
 pub struct DefaultBodyStability {
     pub level: StabilityLevel,
-    pub feature: Symbol,
 }
 
 /// The available stability levels.
@@ -123,31 +121,11 @@ pub struct DefaultBodyStability {
 pub enum StabilityLevel {
     /// `#[unstable]`
     Unstable {
+        /// The information unique to each `#[unstable]` attribute
+        unstables: Unstability,
         /// Reason for the current stability level.
         reason: UnstableReason,
-        /// Relevant `rust-lang/rust` issue.
-        issue: Option<NonZero<u32>>,
         is_soft: bool,
-        /// If part of a feature is stabilized and a new feature is added for the remaining parts,
-        /// then the `implied_by` attribute is used to indicate which now-stable feature previously
-        /// contained an item.
-        ///
-        /// ```pseudo-Rust
-        /// #[unstable(feature = "foo", issue = "...")]
-        /// fn foo() {}
-        /// #[unstable(feature = "foo", issue = "...")]
-        /// fn foobar() {}
-        /// ```
-        ///
-        /// ...becomes...
-        ///
-        /// ```pseudo-Rust
-        /// #[stable(feature = "foo", since = "1.XX.X")]
-        /// fn foo() {}
-        /// #[unstable(feature = "foobar", issue = "...", implied_by = "foo")]
-        /// fn foobar() {}
-        /// ```
-        implied_by: Option<Symbol>,
     },
     /// `#[stable]`
     Stable {
@@ -185,6 +163,35 @@ impl StabilityLevel {
     }
 }
 
+/// An instance of an `#[unstable]`, `#[rustc_const_unstable]`, or similar attribute
+#[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, Hash)]
+#[derive(HashStable_Generic)]
+pub struct Unstability {
+    pub feature: Symbol,
+    /// Relevant `rust-lang/rust` issue.
+    pub issue: Option<NonZero<u32>>,
+    /// If part of a feature is stabilized and a new feature is added for the remaining parts,
+    /// then the `implied_by` attribute is used to indicate which now-stable feature previously
+    /// contained an item.
+    ///
+    /// ```pseudo-Rust
+    /// #[unstable(feature = "foo", issue = "...")]
+    /// fn foo() {}
+    /// #[unstable(feature = "foo", issue = "...")]
+    /// fn foobar() {}
+    /// ```
+    ///
+    /// ...becomes...
+    ///
+    /// ```pseudo-Rust
+    /// #[stable(feature = "foo", since = "1.XX.X")]
+    /// fn foo() {}
+    /// #[unstable(feature = "foobar", issue = "...", implied_by = "foo")]
+    /// fn foobar() {}
+    /// ```
+    pub implied_by: Option<Symbol>,
+}
+
 #[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, Hash)]
 #[derive(HashStable_Generic)]
 pub enum UnstableReason {
@@ -231,8 +238,8 @@ pub fn find_stability(
                     break;
                 }
 
-                if let Some((feature, level)) = parse_unstability(sess, attr) {
-                    stab = Some((Stability { level, feature }, attr.span));
+                if let Some(level) = parse_unstability(sess, attr) {
+                    stab = Some((Stability { level }, attr.span));
                 }
             }
             sym::stable => {
@@ -241,8 +248,8 @@ pub fn find_stability(
                         .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
                     break;
                 }
-                if let Some((feature, level)) = parse_stability(sess, attr) {
-                    stab = Some((Stability { level, feature }, attr.span));
+                if let Some(level) = parse_stability(sess, attr) {
+                    stab = Some((Stability { level }, attr.span));
                 }
             }
             _ => {}
@@ -290,14 +297,9 @@ pub fn find_const_stability(
                     break;
                 }
 
-                if let Some((feature, level)) = parse_unstability(sess, attr) {
+                if let Some(level) = parse_unstability(sess, attr) {
                     const_stab = Some((
-                        ConstStability {
-                            level,
-                            feature,
-                            const_stable_indirect: false,
-                            promotable: false,
-                        },
+                        ConstStability { level, const_stable_indirect: false, promotable: false },
                         attr.span,
                     ));
                 }
@@ -308,14 +310,9 @@ pub fn find_const_stability(
                         .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
                     break;
                 }
-                if let Some((feature, level)) = parse_stability(sess, attr) {
+                if let Some(level) = parse_stability(sess, attr) {
                     const_stab = Some((
-                        ConstStability {
-                            level,
-                            feature,
-                            const_stable_indirect: false,
-                            promotable: false,
-                        },
+                        ConstStability { level, const_stable_indirect: false, promotable: false },
                         attr.span,
                     ));
                 }
@@ -369,12 +366,7 @@ pub fn unmarked_crate_const_stab(
     // We enforce recursive const stability rules for those functions.
     let const_stable_indirect =
         attrs.iter().any(|a| a.name_or_empty() == sym::rustc_const_stable_indirect);
-    ConstStability {
-        feature: regular_stab.feature,
-        const_stable_indirect,
-        promotable: false,
-        level: regular_stab.level,
-    }
+    ConstStability { const_stable_indirect, promotable: false, level: regular_stab.level }
 }
 
 /// Collects stability info from `rustc_default_body_unstable` attributes in `attrs`.
@@ -393,8 +385,8 @@ pub fn find_body_stability(
                 break;
             }
 
-            if let Some((feature, level)) = parse_unstability(sess, attr) {
-                body_stab = Some((DefaultBodyStability { level, feature }, attr.span));
+            if let Some(level) = parse_unstability(sess, attr) {
+                body_stab = Some((DefaultBodyStability { level }, attr.span));
             }
         }
     }
@@ -420,7 +412,7 @@ fn insert_or_error(sess: &Session, meta: &MetaItem, item: &mut Option<Symbol>) -
 
 /// Read the content of a `stable`/`rustc_const_stable` attribute, and return the feature name and
 /// its stability information.
-fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> {
+fn parse_stability(sess: &Session, attr: &Attribute) -> Option<StabilityLevel> {
     let meta = attr.meta()?;
     let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None };
 
@@ -474,17 +466,16 @@ fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabilit
     };
 
     match feature {
-        Ok(feature) => {
-            let level = StabilityLevel::Stable { since, allowed_through_unstable_modules: false };
-            Some((feature, level))
+        Ok(_feature) => {
+            Some(StabilityLevel::Stable { since, allowed_through_unstable_modules: false })
         }
         Err(ErrorGuaranteed { .. }) => None,
     }
 }
 
 /// Read the content of a `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
 /// attribute, and return the feature name and its stability information.
-fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> {
+fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<StabilityLevel> {
     let meta = attr.meta()?;
     let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None };
 
@@ -564,12 +555,11 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
             let level = StabilityLevel::Unstable {
+                unstables: Unstability { feature, issue: issue_num, implied_by },
                 reason: UnstableReason::from_opt_reason(reason),
-                issue: issue_num,
                 is_soft,
-                implied_by,
             };
-            Some((feature, level))
+            Some(level)
         }
         (Err(ErrorGuaranteed { .. }), _) | (_, Err(ErrorGuaranteed { .. })) => None,
     }

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -6,7 +6,7 @@ use std::mem;
 use std::num::NonZero;
 use std::ops::Deref;
 
-use rustc_attr::{ConstStability, StabilityLevel};
+use rustc_attr::{ConstStability, StabilityLevel, Unstability};
 use rustc_errors::{Diag, ErrorGuaranteed};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, LangItem};
@@ -744,13 +744,12 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             }
                         }
                         Some(ConstStability {
-                            level: StabilityLevel::Unstable { .. },
-                            feature,
+                            level: StabilityLevel::Unstable { unstables, .. },
                             ..
                         }) => {
                             self.check_op(ops::IntrinsicUnstable {
                                 name: intrinsic.name,
-                                feature,
+                                feature: unstables.feature,
                                 const_stable_indirect: is_const_stable,
                             });
                         }
@@ -796,10 +795,11 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         }
                     }
                     Some(ConstStability {
-                        level: StabilityLevel::Unstable { implied_by: implied_feature, issue, .. },
-                        feature,
+                        level: StabilityLevel::Unstable { unstables, .. },
                         ..
                     }) => {
+                        let Unstability { feature, implied_by: implied_feature, issue, .. } =
+                            unstables;
                         // An unstable const fn with a feature gate.
                         let callee_safe_to_expose_on_stable =
                             is_safe_to_expose_on_stable_const_fn(tcx, callee);

compiler/rustc_middle/src/middle/stability.rs

@@ -391,11 +391,8 @@ impl<'tcx> TyCtxt<'tcx> {
         );
 
         match stability {
-            Some(Stability {
-                level: attr::Unstable { reason, issue, is_soft, implied_by },
-                feature,
-                ..
-            }) => {
+            Some(Stability { level: attr::Unstable { unstables, reason, is_soft } }) => {
+                let attr::Unstability { feature, issue, implied_by } = unstables;
                 if span.allows_unstable(feature) {
                     debug!("stability: skipping span={:?} since it is internal", span);
                     return EvalResult::Allow;
@@ -474,10 +471,8 @@ impl<'tcx> TyCtxt<'tcx> {
         );
 
         match stability {
-            Some(DefaultBodyStability {
-                level: attr::Unstable { reason, issue, is_soft, .. },
-                feature,
-            }) => {
+            Some(DefaultBodyStability { level: attr::Unstable { unstables, reason, is_soft } }) => {
+                let attr::Unstability { feature, issue, .. } = unstables;
                 if span.allows_unstable(feature) {
                     debug!("body stability: skipping span={:?} since it is internal", span);
                     return EvalResult::Allow;

compiler/rustc_passes/src/stability.rs

@@ -6,7 +6,7 @@ use std::num::NonZero;
 
 use rustc_attr::{
     self as attr, ConstStability, DeprecatedSince, Stability, StabilityLevel, StableSince,
-    Unstable, UnstableReason, VERSION_PLACEHOLDER,
+    Unstability, Unstable, UnstableReason, VERSION_PLACEHOLDER,
 };
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
@@ -224,15 +224,15 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
             // Stable *language* features shouldn't be used as unstable library features.
             // (Not doing this for stable library features is checked by tidy.)
-            if let Stability { level: Unstable { .. }, feature } = stab {
-                if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some() {
+            if let Unstable { unstables, .. } = stab.level {
+                if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == unstables.feature).is_some() {
                     self.tcx
                         .dcx()
                         .emit_err(errors::UnstableAttrForAlreadyStableFeature { span, item_sp });
                 }
             }
-            if let Stability { level: Unstable { implied_by: Some(implied_by), .. }, feature } =
-                stab
+            if let Unstable { unstables, .. } = stab.level
+                && let Unstability { feature, implied_by: Some(implied_by), .. } = unstables
             {
                 self.index.implications.insert(implied_by, feature);
             }
@@ -278,10 +278,10 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
         // Stable *language* features shouldn't be used as unstable library features.
         // (Not doing this for stable library features is checked by tidy.)
-        if let Some((ConstStability { level: Unstable { .. }, feature, .. }, const_span)) =
+        if let Some((ConstStability { level: Unstable { unstables, .. }, .. }, const_span)) =
             const_stab
         {
-            if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some() {
+            if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == unstables.feature).is_some() {
                 self.tcx.dcx().emit_err(errors::UnstableAttrForAlreadyStableFeature {
                     span: const_span,
                     item_sp,
@@ -304,7 +304,6 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                 const_stable_indirect: true,
                 promotable: false,
                 level: inherit_regular_stab.level,
-                feature: inherit_regular_stab.feature,
             });
         }
 
@@ -313,13 +312,10 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             self.index.const_stab_map.insert(def_id, *const_stab);
         });
 
-        if let Some(ConstStability {
-            level: Unstable { implied_by: Some(implied_by), .. },
-            feature,
-            ..
-        }) = const_stab
+        if let Some(ConstStability { level: Unstable { unstables, .. }, .. }) = const_stab
+            && let Some(implied_by) = unstables.implied_by
         {
-            self.index.implications.insert(implied_by, feature);
+            self.index.implications.insert(implied_by, unstables.feature);
         }
 
         // `impl const Trait for Type` items forward their const stability to their
@@ -702,12 +698,14 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
         if tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {
             let stability = Stability {
                 level: attr::StabilityLevel::Unstable {
+                    unstables: attr::Unstability {
+                        feature: sym::rustc_private,
+                        issue: NonZero::new(27812),
+                        implied_by: None,
+                    },
                     reason: UnstableReason::Default,
-                    issue: NonZero::new(27812),
                     is_soft: false,
-                    implied_by: None,
                 },
-                feature: sym::rustc_private,
             };
             annotator.parent_stab = Some(stability);
         }

compiler/rustc_resolve/src/macros.rs

@@ -1003,10 +1003,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     ) {
         let span = path.span;
         if let Some(stability) = &ext.stability {
-            if let StabilityLevel::Unstable { reason, issue, is_soft, implied_by } = stability.level
-            {
-                let feature = stability.feature;
-
+            if let StabilityLevel::Unstable { unstables, reason, is_soft } = stability.level {
+                let rustc_attr::Unstability { feature, issue, implied_by } = unstables;
                 let is_allowed =
                     |feature| self.tcx.features().enabled(feature) || span.allows_unstable(feature);
                 let allowed_by_implication = implied_by.is_some_and(|feature| is_allowed(feature));