factor out some commonalities in the find_stability family of functions

the logic for adding unstable attrs gets a bit messier when supporting multiple
instances thereof. this keeps that from being duplicated in 3 places.

Author: dianne

compiler/rustc_attr/src/builtin.rs

@@ -242,54 +242,40 @@ pub fn find_stability(
     attrs: &[Attribute],
     item_sp: Span,
 ) -> Option<(Stability, Span)> {
-    let mut stab: Option<(Stability, Span)> = None;
+    let mut level: Option<(StabilityLevel, Span)> = None;
     let mut allowed_through_unstable_modules = false;
 
     for attr in attrs {
         match attr.name_or_empty() {
             sym::rustc_allowed_through_unstable_modules => allowed_through_unstable_modules = true,
             sym::unstable => {
-                if stab.is_some() {
-                    sess.dcx()
-                        .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
+                if try_add_unstability(sess, attr, &mut level).is_err() {
                     break;
                 }
-
-                if let Some(level) = parse_unstability(sess, attr) {
-                    stab = Some((Stability { level }, attr.span));
-                }
             }
             sym::stable => {
-                if stab.is_some() {
-                    sess.dcx()
-                        .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
+                if try_add_stability(sess, attr, &mut level).is_err() {
                     break;
                 }
-                if let Some(level) = parse_stability(sess, attr) {
-                    stab = Some((Stability { level }, attr.span));
-                }
             }
             _ => {}
         }
     }
 
     if allowed_through_unstable_modules {
-        match &mut stab {
-            Some((
-                Stability {
-                    level: StabilityLevel::Stable { allowed_through_unstable_modules, .. },
-                    ..
-                },
-                _,
-            )) => *allowed_through_unstable_modules = true,
+        match &mut level {
+            Some((StabilityLevel::Stable { allowed_through_unstable_modules, .. }, _)) => {
+                *allowed_through_unstable_modules = true
+            }
             _ => {
                 sess.dcx()
                     .emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp });
             }
         }
     }
 
-    stab
+    let (level, stab_sp) = level?;
+    Some((Stability { level }, stab_sp))
 }
 
 /// Collects stability info from `rustc_const_stable`/`rustc_const_unstable`/`rustc_promotable`
@@ -302,101 +288,69 @@ pub fn find_const_stability(
     item_sp: Span,
     is_const_fn: bool,
 ) -> Option<(ConstStability, Span)> {
-    let mut const_stab: Option<(ConstStability, Span)> = None;
+    let mut level: Option<(StabilityLevel, 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() {
             sym::rustc_promotable => promotable = true,
             sym::rustc_const_stable_indirect => const_stable_indirect = Some(attr.span),
             sym::rustc_const_unstable => {
-                if const_stab.is_some() {
-                    sess.dcx()
-                        .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
+                if try_add_unstability(sess, attr, &mut level).is_err() {
                     break;
                 }
-
-                if let Some(level) = parse_unstability(sess, attr) {
-                    const_stab = Some((
-                        ConstStability {
-                            level: const_stability_level(level),
-                            const_stable_indirect: false,
-                            promotable: false,
-                        },
-                        attr.span,
-                    ));
-                }
             }
             sym::rustc_const_stable => {
-                if const_stab.is_some() {
-                    sess.dcx()
-                        .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
+                if try_add_stability(sess, attr, &mut level).is_err() {
                     break;
                 }
-                if let Some(level) = parse_stability(sess, attr) {
-                    const_stab = Some((
-                        ConstStability {
-                            level: const_stability_level(level),
-                            const_stable_indirect: false,
-                            promotable: false,
-                        },
-                        attr.span,
-                    ));
-                }
             }
             _ => {}
         }
     }
 
     // Merge promotable and const_stable_indirect into stability info
-    if promotable {
-        match &mut const_stab {
-            Some((stab, _)) => stab.promotable = promotable,
-            _ => {
-                _ = sess
-                    .dcx()
-                    .emit_err(session_diagnostics::RustcPromotablePairing { span: item_sp })
+    let (level, stab_sp) = if let Some((level, stab_sp)) = level {
+        match level {
+            StabilityLevel::Unstable { unstables, .. } => {
+                (ConstStabilityLevel::Unstable { unstables }, stab_sp)
             }
-        }
-    }
-    if const_stable_indirect.is_some() {
-        match &mut const_stab {
-            Some((stab, _)) => {
-                if stab.is_const_unstable() {
-                    stab.const_stable_indirect = true;
-                } else {
-                    _ = sess.dcx().emit_err(session_diagnostics::RustcConstStableIndirectPairing {
+            StabilityLevel::Stable { since, .. } => {
+                if const_stable_indirect.is_some() {
+                    sess.dcx().emit_err(session_diagnostics::RustcConstStableIndirectPairing {
                         span: item_sp,
-                    })
+                    });
                 }
+                (ConstStabilityLevel::Stable { since }, stab_sp)
             }
-            _ => {}
         }
-    }
-    // Make sure if `const_stable_indirect` is present, that is recorded. Also make sure all `const
-    // fn` get *some* marker, since we are a staged_api crate and therefore will do recursive const
-    // stability checks for them. We need to do this because the default for whether an unmarked
-    // function enforces recursive stability differs between staged-api crates and force-unmarked
-    // crates: in force-unmarked crates, only functions *explicitly* marked `const_stable_indirect`
-    // enforce recursive stability. Therefore when `lookup_const_stability` is `None`, we have to
-    // assume the function does not have recursive stability. All functions that *do* have recursive
-    // stability must explicitly record this, and so that's what we do for all `const fn` in a
-    // staged_api crate.
-    if (is_const_fn || const_stable_indirect.is_some()) && const_stab.is_none() {
-        let c = ConstStability {
-            level: ConstStabilityLevel::Implicit,
-            const_stable_indirect: const_stable_indirect.is_some(),
-            promotable: false,
-        };
-        const_stab = Some((c, const_stable_indirect.unwrap_or(DUMMY_SP)));
-    }
+    } else {
+        if promotable {
+            sess.dcx().emit_err(session_diagnostics::RustcPromotablePairing { span: item_sp });
+        }
+        // Make sure if `const_stable_indirect` is present, that is recorded. Also make sure all
+        // `const fn` get *some* marker, since we are a staged_api crate and therefore will do
+        // recursive const stability checks for them. We need to do this because the default for
+        // whether an unmarked function enforces recursive stability differs between staged-api
+        // crates and force-unmarked crates: in force-unmarked crates, only functions *explicitly*
+        // marked `const_stable_indirect` enforce recursive stability. Therefore when
+        // `lookup_const_stability` is `None`, we have to assume the function does not have
+        // recursive stability. All functions that *do* have recursive stability must explicitly
+        // record this, and so that's what we do for all `const fn` in a staged_api crate.
+        if is_const_fn || const_stable_indirect.is_some() {
+            (ConstStabilityLevel::Implicit, const_stable_indirect.unwrap_or(DUMMY_SP))
+        } else {
+            return None;
+        }
+    };
 
-    const_stab
+    let const_stab = ConstStability {
+        level,
+        const_stable_indirect: const_stable_indirect.is_some(),
+        promotable,
+    };
+    Some((const_stab, stab_sp))
 }
 
 /// Collects stability info from `rustc_default_body_unstable` attributes in `attrs`.
@@ -405,23 +359,54 @@ pub fn find_body_stability(
     sess: &Session,
     attrs: &[Attribute],
 ) -> Option<(DefaultBodyStability, Span)> {
-    let mut body_stab: Option<(DefaultBodyStability, Span)> = None;
+    let mut level: Option<(StabilityLevel, Span)> = None;
 
     for attr in attrs {
         if attr.has_name(sym::rustc_default_body_unstable) {
-            if body_stab.is_some() {
-                sess.dcx()
-                    .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
+            if try_add_unstability(sess, attr, &mut level).is_err() {
                 break;
             }
-
-            if let Some(level) = parse_unstability(sess, attr) {
-                body_stab = Some((DefaultBodyStability { level }, attr.span));
-            }
         }
     }
 
-    body_stab
+    let (level, stab_sp) = level?;
+    Some((DefaultBodyStability { level }, stab_sp))
+}
+
+/// Collects stability info from one `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
+/// attribute, `attr`. Emits an error if the info it collects is inconsistent.
+fn try_add_unstability(
+    sess: &Session,
+    attr: &Attribute,
+    level: &mut Option<(StabilityLevel, Span)>,
+) -> Result<(), ErrorGuaranteed> {
+    if level.is_some() {
+        return Err(sess
+            .dcx()
+            .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span }));
+    }
+    if let Some(new_level) = parse_unstability(sess, attr) {
+        *level = Some((new_level, attr.span));
+    }
+    Ok(())
+}
+
+/// Collects stability info from a single `stable`/`rustc_const_stable` attribute, `attr`.
+/// Emits an error if the info it collects is inconsistent.
+fn try_add_stability(
+    sess: &Session,
+    attr: &Attribute,
+    level: &mut Option<(StabilityLevel, Span)>,
+) -> Result<(), ErrorGuaranteed> {
+    if level.is_some() {
+        return Err(sess
+            .dcx()
+            .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span }));
+    }
+    if let Some(new_level) = parse_stability(sess, attr) {
+        *level = Some((new_level, attr.span));
+    }
+    Ok(())
 }
 
 fn insert_or_error(sess: &Session, meta: &MetaItem, item: &mut Option<Symbol>) -> Option<()> {