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`.

As a stopgap, to support the interim const stability check rules, this
additionally introduces `ConstStabilityLevel` and moves the case of
`feature` being `None` to the `ImplicitUnstable` variant for clarity;
having it correspond to an empty `unstables` vec seems like it would be
a footgun.

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,13 +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,
-    /// This can be `None` for functions that do not have an explicit const feature.
-    /// We still track them for recursive const stability checks.
-    pub feature: Option<Symbol>,
+    pub level: ConstStabilityLevel,
     /// This is true iff the `const_stable_indirect` attribute is present.
     pub const_stable_indirect: bool,
     /// whether the function has a `#[rustc_promotable]` attribute
@@ -103,11 +100,15 @@ pub struct ConstStability {
 
 impl ConstStability {
     pub fn is_const_unstable(&self) -> bool {
-        self.level.is_unstable()
+        self.level.is_const_unstable()
     }
 
     pub fn is_const_stable(&self) -> bool {
-        self.level.is_stable()
+        self.level.is_const_stable()
+    }
+
+    pub fn is_implicit_unstable(&self) -> bool {
+        self.level.is_implicit_unstable()
     }
 }
 
@@ -116,7 +117,6 @@ impl ConstStability {
 #[derive(HashStable_Generic)]
 pub struct DefaultBodyStability {
     pub level: StabilityLevel,
-    pub feature: Symbol,
 }
 
 /// The available stability levels.
@@ -125,31 +125,9 @@ pub struct DefaultBodyStability {
 pub enum StabilityLevel {
     /// `#[unstable]`
     Unstable {
-        /// Reason for the current stability level.
-        reason: UnstableReason,
-        /// Relevant `rust-lang/rust` issue.
-        issue: Option<NonZero<u32>>,
+        /// The information unique to each `#[unstable]` attribute
+        unstables: Unstability,
         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 {
@@ -161,6 +139,19 @@ pub enum StabilityLevel {
     },
 }
 
+/// The available const-stability levels for const functions.
+#[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, Hash)]
+#[derive(HashStable_Generic)]
+pub enum ConstStabilityLevel {
+    /// For functions declared const-stable
+    Stable { since: StableSince },
+    /// For functions declared const-unstable
+    Unstable { unstables: Unstability },
+    /// For functions with no explicit const-stability attribute that require checking recursive
+    /// const stability. This is either an unmarked const fn or a `const_stable_indirect` intrinsic.
+    ImplicitUnstable,
+}
+
 /// Rust release in which a feature is stabilized.
 #[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, PartialOrd, Ord, Hash)]
 #[derive(HashStable_Generic)]
@@ -187,6 +178,51 @@ impl StabilityLevel {
     }
 }
 
+impl ConstStabilityLevel {
+    pub fn is_const_unstable(&self) -> bool {
+        matches!(self, ConstStabilityLevel::Unstable { .. } | ConstStabilityLevel::ImplicitUnstable)
+    }
+
+    pub fn is_const_stable(&self) -> bool {
+        matches!(self, ConstStabilityLevel::Stable { .. })
+    }
+
+    pub fn is_implicit_unstable(&self) -> bool {
+        matches!(self, ConstStabilityLevel::ImplicitUnstable)
+    }
+}
+
+/// 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,
+    /// Reason for the current stability level.
+    pub reason: UnstableReason,
+    /// 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 {
@@ -233,8 +269,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 => {
@@ -243,8 +279,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));
                 }
             }
             _ => {}
@@ -283,6 +319,10 @@ pub fn find_const_stability(
     let mut const_stab: Option<(ConstStability, Span)> = None;
     let mut promotable = false;
     let mut const_stable_indirect = None;
+    let const_stability_level = |level| match level {
+        StabilityLevel::Unstable { unstables, .. } => ConstStabilityLevel::Unstable { unstables },
+        StabilityLevel::Stable { since, .. } => ConstStabilityLevel::Stable { since },
+    };
 
     for attr in attrs {
         match attr.name_or_empty() {
@@ -295,11 +335,10 @@ 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: Some(feature),
+                            level: const_stability_level(level),
                             const_stable_indirect: false,
                             promotable: false,
                         },
@@ -313,11 +352,10 @@ 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: Some(feature),
+                            level: const_stability_level(level),
                             const_stable_indirect: false,
                             promotable: false,
                         },
@@ -365,15 +403,9 @@ pub fn find_const_stability(
     // staged_api crate.
     if (is_const_fn || const_stable_indirect.is_some()) && const_stab.is_none() {
         let c = ConstStability {
-            feature: None,
+            level: ConstStabilityLevel::ImplicitUnstable,
             const_stable_indirect: const_stable_indirect.is_some(),
             promotable: false,
-            level: StabilityLevel::Unstable {
-                reason: UnstableReason::Default,
-                issue: None,
-                is_soft: false,
-                implied_by: None,
-            },
         };
         const_stab = Some((c, const_stable_indirect.unwrap_or(DUMMY_SP)));
     }
@@ -397,8 +429,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));
             }
         }
     }
@@ -424,7 +456,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 };
 
@@ -478,17 +510,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 };
 
@@ -568,12 +599,15 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
             let level = StabilityLevel::Unstable {
-                reason: UnstableReason::from_opt_reason(reason),
-                issue: issue_num,
+                unstables: Unstability {
+                    feature,
+                    reason: UnstableReason::from_opt_reason(reason),
+                    issue: issue_num,
+                    implied_by,
+                },
                 is_soft,
-                implied_by,
             };
-            Some((feature, level))
+            Some(level)
         }
         (Err(ErrorGuaranteed { .. }), _) | (_, Err(ErrorGuaranteed { .. })) => None,
     }

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -5,7 +5,7 @@ use std::borrow::Cow;
 use std::mem;
 use std::ops::Deref;
 
-use rustc_attr::{ConstStability, StabilityLevel};
+use rustc_attr::{ConstStability, ConstStabilityLevel, Unstability};
 use rustc_errors::{Diag, ErrorGuaranteed};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, LangItem};
@@ -723,7 +723,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             // Non-const intrinsic.
                             self.check_op(ops::IntrinsicNonConst { name: intrinsic.name });
                         }
-                        Some(ConstStability { feature: None, .. }) => {
+                        Some(ConstStability {
+                            level: ConstStabilityLevel::ImplicitUnstable,
+                            ..
+                        }) => {
                             // Intrinsic does not need a separate feature gate (we rely on the
                             // regular stability checker). However, we have to worry about recursive
                             // const stability.
@@ -735,17 +738,18 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             }
                         }
                         Some(ConstStability {
-                            feature: Some(feature),
-                            level: StabilityLevel::Unstable { .. },
+                            level: ConstStabilityLevel::Unstable { unstables },
                             ..
                         }) => {
                             self.check_op(ops::IntrinsicUnstable {
                                 name: intrinsic.name,
-                                feature,
+                                feature: unstables.feature,
                                 const_stable: is_const_stable,
                             });
                         }
-                        Some(ConstStability { level: StabilityLevel::Stable { .. }, .. }) => {
+                        Some(ConstStability {
+                            level: ConstStabilityLevel::Stable { .. }, ..
+                        }) => {
                             // All good. Note that a `#[rustc_const_stable]` intrinsic (meaning it
                             // can be *directly* invoked from stable const code) does not always
                             // have the `#[rustc_const_stable_intrinsic]` attribute (which controls
@@ -770,10 +774,13 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
                 // Finally, stability for regular function calls -- this is the big one.
                 match tcx.lookup_const_stability(callee) {
-                    Some(ConstStability { level: StabilityLevel::Stable { .. }, .. }) => {
+                    Some(ConstStability { level: ConstStabilityLevel::Stable { .. }, .. }) => {
                         // All good.
                     }
-                    None | Some(ConstStability { feature: None, .. }) => {
+                    None
+                    | Some(ConstStability {
+                        level: ConstStabilityLevel::ImplicitUnstable, ..
+                    }) => {
                         // This doesn't need a separate const-stability check -- const-stability equals
                         // regular stability, and regular stability is checked separately.
                         // However, we *do* have to worry about *recursive* const stability.
@@ -787,10 +794,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         }
                     }
                     Some(ConstStability {
-                        feature: Some(feature),
-                        level: StabilityLevel::Unstable { implied_by: implied_feature, .. },
+                        level: ConstStabilityLevel::Unstable { unstables },
                         ..
                     }) => {
+                        let Unstability { feature, implied_by: implied_feature, .. } = 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_const_eval/src/check_consts/mod.rs

@@ -116,7 +116,7 @@ pub fn is_safe_to_expose_on_stable_const_fn(tcx: TyCtxt<'_>, def_id: DefId) -> b
         Some(stab) => {
             // We consider things safe-to-expose if they are stable, if they don't have any explicit
             // const stability attribute, or if they are marked as `const_stable_indirect`.
-            stab.is_const_stable() || stab.feature.is_none() || stab.const_stable_indirect
+            stab.is_const_stable() || stab.is_implicit_unstable() || stab.const_stable_indirect
         }
     }
 }