move stability structs' feature fields into StabilityLevel::Unstable

dianne · dianne · commit 3c6fe0a19faf · 2024-10-23T12:32:14.000-07:00
This is a refactor for supporting 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`.
diff --git a/compiler/rustc_attr/src/builtin.rs b/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 {
@@ -92,7 +91,6 @@ impl Stability {
 #[derive(HashStable_Generic)]
 pub struct ConstStability {
     pub level: StabilityLevel,
-    pub feature: Symbol,
     /// whether the function has a `#[rustc_promotable]` attribute
     pub promotable: bool,
 }
@@ -112,7 +110,6 @@ impl ConstStability {
 #[derive(HashStable_Generic)]
 pub struct DefaultBodyStability {
     pub level: StabilityLevel,
-    pub feature: Symbol,
 }
 
 /// The available stability levels.
@@ -121,6 +118,7 @@ pub struct DefaultBodyStability {
 pub enum StabilityLevel {
     /// `#[unstable]`
     Unstable {
+        feature: Symbol,
         /// Reason for the current stability level.
         reason: UnstableReason,
         /// Relevant `rust-lang/rust` issue.
@@ -229,8 +227,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 => {
@@ -239,8 +237,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));
                 }
             }
             _ => {}
@@ -286,9 +284,8 @@ pub fn find_const_stability(
                     break;
                 }
 
-                if let Some((feature, level)) = parse_unstability(sess, attr) {
-                    const_stab =
-                        Some((ConstStability { level, feature, promotable: false }, attr.span));
+                if let Some(level) = parse_unstability(sess, attr) {
+                    const_stab = Some((ConstStability { level, promotable: false }, attr.span));
                 }
             }
             sym::rustc_const_stable => {
@@ -297,9 +294,8 @@ pub fn find_const_stability(
                         .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
                     break;
                 }
-                if let Some((feature, level)) = parse_stability(sess, attr) {
-                    const_stab =
-                        Some((ConstStability { level, feature, promotable: false }, attr.span));
+                if let Some(level) = parse_stability(sess, attr) {
+                    const_stab = Some((ConstStability { level, promotable: false }, attr.span));
                 }
             }
             _ => {}
@@ -337,8 +333,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));
             }
         }
     }
@@ -364,7 +360,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 };
 
@@ -418,17 +414,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 };
 
@@ -508,12 +503,13 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
             let level = StabilityLevel::Unstable {
+                feature,
                 reason: UnstableReason::from_opt_reason(reason),
                 issue: issue_num,
                 is_soft,
                 implied_by,
             };
-            Some((feature, level))
+            Some(level)
         }
         (Err(ErrorGuaranteed { .. }), _) | (_, Err(ErrorGuaranteed { .. })) => None,
     }
diff --git a/compiler/rustc_const_eval/src/const_eval/fn_queries.rs b/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
@@ -11,8 +11,8 @@ pub fn is_unstable_const_fn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<(Symbol, O
     if tcx.is_const_fn_raw(def_id) {
         let const_stab = tcx.lookup_const_stability(def_id)?;
         match const_stab.level {
-            attr::StabilityLevel::Unstable { implied_by, .. } => {
-                Some((const_stab.feature, implied_by))
+            attr::StabilityLevel::Unstable { feature, implied_by, .. } => {
+                Some((feature, implied_by))
             }
             attr::StabilityLevel::Stable { .. } => None,
         }
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
@@ -414,9 +414,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
         match stability {
             Some(Stability {
-                level: attr::Unstable { reason, issue, is_soft, implied_by },
-                feature,
-                ..
+                level: attr::Unstable { feature, reason, issue, is_soft, implied_by },
             }) => {
                 if span.allows_unstable(feature) {
                     debug!("stability: skipping span={:?} since it is internal", span);
@@ -502,8 +500,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
         match stability {
             Some(DefaultBodyStability {
-                level: attr::Unstable { reason, issue, is_soft, .. },
-                feature,
+                level: attr::Unstable { feature, reason, issue, is_soft, .. },
             }) => {
                 if span.allows_unstable(feature) {
                     debug!("body stability: skipping span={:?} since it is internal", span);
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -3110,10 +3110,13 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn is_const_fn(self, def_id: DefId) -> bool {
         if self.is_const_fn_raw(def_id) {
             match self.lookup_const_stability(def_id) {
-                Some(stability) if stability.is_const_unstable() => {
+                Some(rustc_attr::ConstStability {
+                    level: rustc_attr::Unstable { feature, .. },
+                    ..
+                }) => {
                     // has a `rustc_const_unstable` attribute, check whether the user enabled the
                     // corresponding feature gate.
-                    self.features().enabled(stability.feature)
+                    self.features().enabled(feature)
                 }
                 // functions without const stability are either stable user written
                 // const fn or the user is using feature gates and we thus don't
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
@@ -247,20 +247,18 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                 }
             }
 
-            if let Stability { level: Unstable { .. }, feature } = stab {
+            if let Unstable { feature, .. } = stab.level {
                 if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == 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 { feature, implied_by: Some(implied_by), .. } = stab.level {
                 self.index.implications.insert(implied_by, feature);
             }
 
-            if let Some(ConstStability { level: Unstable { .. }, feature, .. }) = const_stab {
+            if let Some(ConstStability { level: Unstable { feature, .. }, .. }) = const_stab {
                 if ACCEPTED_LANG_FEATURES.iter().find(|f| f.name == feature).is_some() {
                     self.tcx.dcx().emit_err(errors::UnstableAttrForAlreadyStableFeature {
                         span: const_span.unwrap(), // If const_stab contains Some(..), same is true for const_span
@@ -269,8 +267,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                 }
             }
             if let Some(ConstStability {
-                level: Unstable { implied_by: Some(implied_by), .. },
-                feature,
+                level: Unstable { feature, implied_by: Some(implied_by), .. },
                 ..
             }) = const_stab
             {
@@ -656,12 +653,12 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {
         if tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {
             let stability = Stability {
                 level: attr::StabilityLevel::Unstable {
+                    feature: sym::rustc_private,
                     reason: UnstableReason::Default,
                     issue: NonZero::new(27812),
                     is_soft: false,
                     implied_by: None,
                 },
-                feature: sym::rustc_private,
             };
             annotator.parent_stab = Some(stability);
         }
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
@@ -1003,10 +1003,9 @@ 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
+            if let StabilityLevel::Unstable { feature, reason, issue, is_soft, implied_by } =
+                stability.level
             {
-                let feature = stability.feature;
-
                 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));

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,6 @@ pub enum OptimizeAttr {`
`70`	`70`	`#[derive(HashStable_Generic)]`
`71`	`71`	`pub struct Stability {`
`72`	`72`	`pub level: StabilityLevel,`
`73`		`- pub feature: Symbol,`
`74`	`73`	`}`
`75`	`74`
`76`	`75`	`impl Stability {`
`@@ -92,7 +91,6 @@ impl Stability {`
`92`	`91`	`#[derive(HashStable_Generic)]`
`93`	`92`	`pub struct ConstStability {`
`94`	`93`	`pub level: StabilityLevel,`
`95`		`- pub feature: Symbol,`
`96`	`94`	/// whether the function has a `#[rustc_promotable]` attribute
`97`	`95`	`pub promotable: bool,`
`98`	`96`	`}`
`@@ -112,7 +110,6 @@ impl ConstStability {`
`112`	`110`	`#[derive(HashStable_Generic)]`
`113`	`111`	`pub struct DefaultBodyStability {`
`114`	`112`	`pub level: StabilityLevel,`
`115`		`- pub feature: Symbol,`
`116`	`113`	`}`
`117`	`114`
`118`	`115`	`/// The available stability levels.`
`@@ -121,6 +118,7 @@ pub struct DefaultBodyStability {`
`121`	`118`	`pub enum StabilityLevel {`
`122`	`119`	/// `#[unstable]`
`123`	`120`	`Unstable {`
	`121`	`+ feature: Symbol,`
`124`	`122`	`/// Reason for the current stability level.`
`125`	`123`	`reason: UnstableReason,`
`126`	`124`	/// Relevant `rust-lang/rust` issue.
`@@ -229,8 +227,8 @@ pub fn find_stability(`
`229`	`227`	`break;`
`230`	`228`	`}`
`231`	`229`
`232`		`- if let Some((feature, level)) = parse_unstability(sess, attr) {`
`233`		`- stab = Some((Stability { level, feature }, attr.span));`
	`230`	`+ if let Some(level) = parse_unstability(sess, attr) {`
	`231`	`+ stab = Some((Stability { level }, attr.span));`
`234`	`232`	`}`
`235`	`233`	`}`
`236`	`234`	`sym::stable => {`
`@@ -239,8 +237,8 @@ pub fn find_stability(`
`239`	`237`	`.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });`
`240`	`238`	`break;`
`241`	`239`	`}`
`242`		`- if let Some((feature, level)) = parse_stability(sess, attr) {`
`243`		`- stab = Some((Stability { level, feature }, attr.span));`
	`240`	`+ if let Some(level) = parse_stability(sess, attr) {`
	`241`	`+ stab = Some((Stability { level }, attr.span));`
`244`	`242`	`}`
`245`	`243`	`}`
`246`	`244`	`_ => {}`
`@@ -286,9 +284,8 @@ pub fn find_const_stability(`
`286`	`284`	`break;`
`287`	`285`	`}`
`288`	`286`
`289`		`- if let Some((feature, level)) = parse_unstability(sess, attr) {`
`290`		`- const_stab =`
`291`		`- Some((ConstStability { level, feature, promotable: false }, attr.span));`
	`287`	`+ if let Some(level) = parse_unstability(sess, attr) {`
	`288`	`+ const_stab = Some((ConstStability { level, promotable: false }, attr.span));`
`292`	`289`	`}`
`293`	`290`	`}`
`294`	`291`	`sym::rustc_const_stable => {`
`@@ -297,9 +294,8 @@ pub fn find_const_stability(`
`297`	`294`	`.emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });`
`298`	`295`	`break;`
`299`	`296`	`}`
`300`		`- if let Some((feature, level)) = parse_stability(sess, attr) {`
`301`		`- const_stab =`
`302`		`- Some((ConstStability { level, feature, promotable: false }, attr.span));`
	`297`	`+ if let Some(level) = parse_stability(sess, attr) {`
	`298`	`+ const_stab = Some((ConstStability { level, promotable: false }, attr.span));`
`303`	`299`	`}`
`304`	`300`	`}`
`305`	`301`	`_ => {}`
`@@ -337,8 +333,8 @@ pub fn find_body_stability(`
`337`	`333`	`break;`
`338`	`334`	`}`
`339`	`335`
`340`		`- if let Some((feature, level)) = parse_unstability(sess, attr) {`
`341`		`- body_stab = Some((DefaultBodyStability { level, feature }, attr.span));`
	`336`	`+ if let Some(level) = parse_unstability(sess, attr) {`
	`337`	`+ body_stab = Some((DefaultBodyStability { level }, attr.span));`
`342`	`338`	`}`
`343`	`339`	`}`
`344`	`340`	`}`
`@@ -364,7 +360,7 @@ fn insert_or_error(sess: &Session, meta: &MetaItem, item: &mut Option<Symbol>) -`
`364`	`360`
`365`	`361`	/// Read the content of a `stable`/`rustc_const_stable` attribute, and return the feature name and
`366`	`362`	`/// its stability information.`
`367`		`-fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> {`
	`363`	`+fn parse_stability(sess: &Session, attr: &Attribute) -> Option<StabilityLevel> {`
`368`	`364`	`let meta = attr.meta()?;`
`369`	`365`	`let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None };`
`370`	`366`
`@@ -418,17 +414,16 @@ fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabilit`
`418`	`414`	`};`
`419`	`415`
`420`	`416`	`match feature {`
`421`		`- Ok(feature) => {`
`422`		`- let level = StabilityLevel::Stable { since, allowed_through_unstable_modules: false };`
`423`		`- Some((feature, level))`
	`417`	`+ Ok(_feature) => {`
	`418`	`+ Some(StabilityLevel::Stable { since, allowed_through_unstable_modules: false })`
`424`	`419`	`}`
`425`	`420`	`Err(ErrorGuaranteed { .. }) => None,`
`426`	`421`	`}`
`427`	`422`	`}`
`428`	`423`
`429`	`424`	/// Read the content of a `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
`430`	`425`	`/// attribute, and return the feature name and its stability information.`
`431`		`-fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> {`
	`426`	`+fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<StabilityLevel> {`
`432`	`427`	`let meta = attr.meta()?;`
`433`	`428`	`let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None };`
`434`	`429`
`@@ -508,12 +503,13 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil`
`508`	`503`	`match (feature, issue) {`
`509`	`504`	`(Ok(feature), Ok(_)) => {`
`510`	`505`	`let level = StabilityLevel::Unstable {`
	`506`	`+ feature,`
`511`	`507`	`reason: UnstableReason::from_opt_reason(reason),`
`512`	`508`	`issue: issue_num,`
`513`	`509`	`is_soft,`
`514`	`510`	`implied_by,`
`515`	`511`	`};`
`516`		`- Some((feature, level))`
	`512`	`+ Some(level)`
`517`	`513`	`}`
`518`	`514`	`(Err(ErrorGuaranteed { .. }), _) \| (_, Err(ErrorGuaranteed { .. })) => None,`
`519`	`515`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,8 @@ pub fn is_unstable_const_fn(tcx: TyCtxt<'_>, def_id: DefId) -> Option<(Symbol, O`
`11`	`11`	`if tcx.is_const_fn_raw(def_id) {`
`12`	`12`	`let const_stab = tcx.lookup_const_stability(def_id)?;`
`13`	`13`	`match const_stab.level {`
`14`		`- attr::StabilityLevel::Unstable { implied_by, .. } => {`
`15`		`- Some((const_stab.feature, implied_by))`
	`14`	`+ attr::StabilityLevel::Unstable { feature, implied_by, .. } => {`
	`15`	`+ Some((feature, implied_by))`
`16`	`16`	`}`
`17`	`17`	`attr::StabilityLevel::Stable { .. } => None,`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -247,20 +247,18 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`
`250`		`- if let Stability { level: Unstable { .. }, feature } = stab {`
	`250`	`+ if let Unstable { feature, .. } = stab.level {`
`251`	`251`	`if ACCEPTED_LANG_FEATURES.iter().find(\|f\| f.name == feature).is_some() {`
`252`	`252`	`self.tcx`
`253`	`253`	`.dcx()`
`254`	`254`	`.emit_err(errors::UnstableAttrForAlreadyStableFeature { span, item_sp });`
`255`	`255`	`}`
`256`	`256`	`}`
`257`		`- if let Stability { level: Unstable { implied_by: Some(implied_by), .. }, feature } =`
`258`		`- stab`
`259`		`- {`
	`257`	`+ if let Unstable { feature, implied_by: Some(implied_by), .. } = stab.level {`
`260`	`258`	`self.index.implications.insert(implied_by, feature);`
`261`	`259`	`}`
`262`	`260`
`263`		`- if let Some(ConstStability { level: Unstable { .. }, feature, .. }) = const_stab {`
	`261`	`+ if let Some(ConstStability { level: Unstable { feature, .. }, .. }) = const_stab {`
`264`	`262`	`if ACCEPTED_LANG_FEATURES.iter().find(\|f\| f.name == feature).is_some() {`
`265`	`263`	`self.tcx.dcx().emit_err(errors::UnstableAttrForAlreadyStableFeature {`
`266`	`264`	`span: const_span.unwrap(), // If const_stab contains Some(..), same is true for const_span`
`@@ -269,8 +267,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {`
`269`	`267`	`}`
`270`	`268`	`}`
`271`	`269`	`if let Some(ConstStability {`
`272`		`- level: Unstable { implied_by: Some(implied_by), .. },`
`273`		`- feature,`
	`270`	`+ level: Unstable { feature, implied_by: Some(implied_by), .. },`
`274`	`271`	`..`
`275`	`272`	`}) = const_stab`
`276`	`273`	`{`
`@@ -656,12 +653,12 @@ fn stability_index(tcx: TyCtxt<'_>, (): ()) -> Index {`
`656`	`653`	`if tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {`
`657`	`654`	`let stability = Stability {`
`658`	`655`	`level: attr::StabilityLevel::Unstable {`
	`656`	`+ feature: sym::rustc_private,`
`659`	`657`	`reason: UnstableReason::Default,`
`660`	`658`	`issue: NonZero::new(27812),`
`661`	`659`	`is_soft: false,`
`662`	`660`	`implied_by: None,`
`663`	`661`	`},`
`664`		`- feature: sym::rustc_private,`
`665`	`662`	`};`
`666`	`663`	`annotator.parent_stab = Some(stability);`
`667`	`664`	`}`