support multiple stability attributes (a mix of stable and unstable)

An item is unstable if it has any unstable attributes, to make it easier to track which features
library items depended on as they stabilize.

This changes the text for E0544. Unfortunately, the example doesn't make much sense anymore.

The way this merges stability levels together is made to work for stability-checking and rustdoc;
as far as I can tell, only `rustc_passes::lib_features` needs them separate, and it extracts them
itself.

Author: dianne

compiler/rustc_attr/messages.ftl

@@ -83,7 +83,7 @@ attr_multiple_item =
     multiple '{$item}' items
 
 attr_multiple_stability_levels =
-    multiple stability levels
+    multiple stability levels for feature `{$feature}`
 
 attr_non_ident_feature =
     'feature' is not an identifier

compiler/rustc_attr/src/builtin.rs

@@ -266,13 +266,18 @@ pub fn find_stability(
 ) -> Option<(Stability, StabilitySpans)> {
     let mut level: Option<StabilityLevel> = None;
     let mut stab_spans = StabilitySpans(smallvec![]);
+    let mut features = smallvec![];
     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 => try_add_unstability(sess, attr, &mut level, &mut stab_spans),
-            sym::stable => try_add_stability(sess, attr, &mut level, &mut stab_spans),
+            sym::unstable => {
+                add_level(sess, attr, &mut level, &mut stab_spans, &mut features, parse_unstability)
+            }
+            sym::stable => {
+                add_level(sess, attr, &mut level, &mut stab_spans, &mut features, parse_stability)
+            }
             _ => {}
         }
     }
@@ -301,15 +306,18 @@ pub fn find_const_stability(
 ) -> Option<(ConstStability, StabilitySpans)> {
     let mut level: Option<StabilityLevel> = None;
     let mut stab_spans = StabilitySpans(smallvec![]);
+    let mut features = smallvec![];
     let mut promotable = false;
 
     for attr in attrs {
         match attr.name_or_empty() {
             sym::rustc_promotable => promotable = true,
             sym::rustc_const_unstable => {
-                try_add_unstability(sess, attr, &mut level, &mut stab_spans)
+                add_level(sess, attr, &mut level, &mut stab_spans, &mut features, parse_unstability)
+            }
+            sym::rustc_const_stable => {
+                add_level(sess, attr, &mut level, &mut stab_spans, &mut features, parse_stability)
             }
-            sym::rustc_const_stable => try_add_stability(sess, attr, &mut level, &mut stab_spans),
             _ => {}
         }
     }
@@ -333,76 +341,63 @@ pub fn find_body_stability(
 ) -> Option<(DefaultBodyStability, StabilitySpans)> {
     let mut level: Option<StabilityLevel> = None;
     let mut stab_spans = StabilitySpans(smallvec![]);
+    let mut features = smallvec![];
 
     for attr in attrs {
         if attr.has_name(sym::rustc_default_body_unstable) {
-            try_add_unstability(sess, attr, &mut level, &mut stab_spans);
+            add_level(sess, attr, &mut level, &mut stab_spans, &mut features, parse_unstability);
         }
     }
 
     Some((DefaultBodyStability { level: level? }, stab_spans))
 }
 
-/// 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(
+/// Collects stability info from one stability attribute, `attr`.
+/// Emits an error if multiple stability levels are found for the same feature.
+fn add_level(
     sess: &Session,
     attr: &Attribute,
-    level: &mut Option<StabilityLevel>,
+    total_level: &mut Option<StabilityLevel>,
     stab_spans: &mut StabilitySpans,
+    features: &mut SmallVec<[Symbol; 1]>,
+    parse_level: impl FnOnce(&Session, &Attribute) -> Option<(Symbol, StabilityLevel)>,
 ) {
     use StabilityLevel::*;
 
-    match level {
-        // adding #[unstable] to an item with #[stable] is not permitted
-        Some(Stable { .. }) => {
-            sess.dcx().emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
-        }
-        // if other unstable attributes have been found, attempt to merge them
-        Some(Unstable { unstables, is_soft })
-            if let Some(Unstable { unstables: new_unstable, is_soft: new_soft }) =
-                parse_unstability(sess, attr) =>
-        {
-            // sanity check: is this the only unstable attr of its kind for its feature?
-            // FIXME(dianne): should this have a new error associated with it or is "multiple
-            // stability levels" clear enough, given an update to E0544.md?
-            // should MultipleStabilityLevels have more fields for diagnostics?
-            if unstables.iter().any(|u| new_unstable.iter().any(|v| u.feature == v.feature)) {
-                sess.dcx()
-                    .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
-                return;
-            }
-            unstables.extend(new_unstable.clone());
+    let Some((feature, feature_level)) = parse_level(sess, attr) else { return };
+
+    // sanity check: is this the only stability level of its kind for its feature?
+    if features.contains(&feature) {
+        sess.dcx()
+            .emit_err(session_diagnostics::MultipleStabilityLevels { feature, span: attr.span });
+    }
+    features.push(feature);
+    stab_spans.0.push((feature_level.clone(), attr.span));
+
+    match (total_level, feature_level) {
+        (level @ None, new_level) => *level = Some(new_level),
+        // if multiple unstable attributes have been found, merge them
+        (
+            Some(Unstable { unstables, is_soft }),
+            Unstable { unstables: new_unstable, is_soft: new_soft },
+        ) => {
+            unstables.extend(new_unstable);
             // Make the unstability soft if any unstable attributes are marked 'soft'; if an
             // unstable item is allowed in stable rust, another attribute shouldn't break that.
             // FIXME(dianne): should there be a check that all unstables are soft if any are?
             *is_soft |= new_soft;
-            stab_spans.0.push((Unstable { unstables: new_unstable, is_soft: new_soft }, attr.span));
         }
-        // if this is the first unstability of its kind on an item, collect it
-        None if let Some(new_level) = parse_unstability(sess, attr) => {
-            *level = Some(new_level.clone());
-            stab_spans.0.push((new_level, attr.span));
+        // an item with some stable and some unstable features is unstable
+        (Some(Unstable { .. }), Stable { .. }) => {}
+        (Some(level @ Stable { .. }), new_level @ Unstable { .. }) => *level = new_level,
+        // if multiple stable attributes have been found, use the most recent stabilization date
+        (
+            Some(Stable { since, allowed_through_unstable_modules }),
+            Stable { since: new_since, allowed_through_unstable_modules: new_allowed },
+        ) => {
+            *since = StableSince::max(*since, new_since);
+            *allowed_through_unstable_modules |= new_allowed;
         }
-        // if there was an error in `parse_unstability`, it's already been emitted; do nothing
-        _ => {}
-    }
-}
-
-/// 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>,
-    stab_spans: &mut StabilitySpans,
-) {
-    // at most one #[stable] attribute is permitted, and not when #[unstable] is present
-    if level.is_some() {
-        sess.dcx().emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span });
-    } else if let Some(new_level) = parse_stability(sess, attr) {
-        *level = Some(new_level.clone());
-        stab_spans.0.push((new_level, attr.span));
     }
 }
 
@@ -424,7 +419,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<StabilityLevel> {
+fn parse_stability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> {
     let meta = attr.meta()?;
     let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None };
 
@@ -478,16 +473,17 @@ fn parse_stability(sess: &Session, attr: &Attribute) -> Option<StabilityLevel> {
     };
 
     match feature {
-        Ok(_feature) => {
-            Some(StabilityLevel::Stable { since, allowed_through_unstable_modules: false })
-        }
+        Ok(feature) => Some((feature, 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<StabilityLevel> {
+fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, StabilityLevel)> {
     let meta = attr.meta()?;
     let MetaItem { kind: MetaItemKind::List(ref metas), .. } = meta else { return None };
 
@@ -572,7 +568,7 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<StabilityLevel>
                 issue: issue_num,
                 implied_by,
             };
-            Some(StabilityLevel::Unstable { unstables: smallvec![unstability], is_soft })
+            Some((feature, StabilityLevel::Unstable { unstables: smallvec![unstability], is_soft }))
         }
         (Err(ErrorGuaranteed { .. }), _) | (_, Err(ErrorGuaranteed { .. })) => None,
     }

compiler/rustc_attr/src/lib.rs

@@ -7,7 +7,6 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![doc(rust_logo)]
-#![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
 #![warn(unreachable_pub)]

compiler/rustc_attr/src/session_diagnostics.rs

@@ -79,6 +79,8 @@ pub(crate) struct MissingNote {
 pub(crate) struct MultipleStabilityLevels {
     #[primary_span]
     pub span: Span,
+
+    pub feature: Symbol,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_error_codes/src/error_codes/E0544.md

@@ -1,4 +1,4 @@
-Multiple stability attributes were declared on the same item.
+Multiple stability attributes were declared for the same feature on one item.
 
 Erroneous code example:
 
@@ -8,18 +8,19 @@ Erroneous code example:
 #![stable(since = "1.0.0", feature = "rust1")]
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[stable(feature = "test", since = "2.0.0")] // invalid
+#[stable(feature = "rust1", since = "1.0.0")] // invalid
 fn foo() {}
 ```
 
-To fix this issue, ensure that each item has at most one stability attribute.
+To fix this issue, ensure that each item has at most one stability attribute per
+feature.
 
 ```
 #![feature(staged_api)]
 #![allow(internal_features)]
 #![stable(since = "1.0.0", feature = "rust1")]
 
-#[stable(feature = "test", since = "2.0.0")] // ok!
+#[stable(feature = "rust1", since = "1.0.0")] // ok!
 fn foo() {}
 ```
 

compiler/rustc_passes/src/stability.rs

@@ -230,8 +230,10 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                 &depr.as_ref().map(|(d, _)| d.since)
                 && let Some(stab_since) = stab.stable_since()
             {
-                let &(_, span) =
-                    stab_spans.iter().nth(0).expect("expected one span with a stable attribute");
+                let &(_, span) = stab_spans
+                    .iter()
+                    .find(|(level, _)| level.stable_since() == Some(stab_since))
+                    .expect("stabilization version should have an associated span");
 
                 match stab_since {
                     StableSince::Current => {

tests/ui/stability-attribute/stability-attribute-sanity.rs

@@ -45,23 +45,23 @@ mod missing_version {
     fn f3() { }
 }
 
-#[unstable(feature = "b", issue = "none")]
-#[stable(feature = "a", since = "4.4.4")] //~ ERROR multiple stability levels [E0544]
+#[stable(feature = "a", since = "4.4.4")]
+#[stable(feature = "a", since = "4.4.4")] //~ ERROR multiple stability levels for feature `a` [E0544]
 fn multiple1() { }
 
 #[unstable(feature = "b", issue = "none")]
-#[unstable(feature = "b", issue = "none")] //~ ERROR multiple stability levels [E0544]
+#[unstable(feature = "b", issue = "none")] //~ ERROR multiple stability levels for feature `b` [E0544]
 fn multiple2() { }
 
-#[stable(feature = "a", since = "4.4.4")]
-#[stable(feature = "a", since = "4.4.4")] //~ ERROR multiple stability levels [E0544]
-fn multiple3() { }
+#[unstable(feature = "c", issue = "none")]
+#[stable(feature = "c", since = "4.4.4")] //~ ERROR multiple stability levels for feature `c` [E0544]
+fn multiple3() { }                       //~| ERROR feature `c` is declared stable, but was previously declared unstable
 
 #[stable(feature = "e", since = "b")] //~ ERROR 'since' must be a Rust version number, such as "1.31.0"
 #[deprecated(since = "5.5.5", note = "text")]
 #[deprecated(since = "5.5.5", note = "text")] //~ ERROR multiple `deprecated` attributes
 #[rustc_const_unstable(feature = "d", issue = "none")]
-#[rustc_const_unstable(feature = "d", issue = "none")] //~ ERROR multiple stability levels
+#[rustc_const_unstable(feature = "d", issue = "none")] //~ ERROR multiple stability levels for feature `d`
 pub const fn multiple4() { }
 
 #[stable(feature = "a", since = "1.0.0")] //~ ERROR feature `a` is declared stable since 1.0.0

tests/ui/stability-attribute/stability-attribute-sanity.stderr

@@ -76,22 +76,22 @@ error[E0543]: missing 'note'
 LL |     #[deprecated(since = "5.5.5")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0544]: multiple stability levels
+error[E0544]: multiple stability levels for feature `a`
   --> $DIR/stability-attribute-sanity.rs:49:1
    |
 LL | #[stable(feature = "a", since = "4.4.4")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0544]: multiple stability levels
+error[E0544]: multiple stability levels for feature `b`
   --> $DIR/stability-attribute-sanity.rs:53:1
    |
 LL | #[unstable(feature = "b", issue = "none")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0544]: multiple stability levels
+error[E0544]: multiple stability levels for feature `c`
   --> $DIR/stability-attribute-sanity.rs:57:1
    |
-LL | #[stable(feature = "a", since = "4.4.4")]
+LL | #[stable(feature = "c", since = "4.4.4")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: 'since' must be a Rust version number, such as "1.31.0"
@@ -100,7 +100,7 @@ error: 'since' must be a Rust version number, such as "1.31.0"
 LL | #[stable(feature = "e", since = "b")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0544]: multiple stability levels
+error[E0544]: multiple stability levels for feature `d`
   --> $DIR/stability-attribute-sanity.rs:64:1
    |
 LL | #[rustc_const_unstable(feature = "d", issue = "none")]
@@ -118,13 +118,19 @@ error[E0549]: deprecated attribute must be paired with either stable or unstable
 LL | #[deprecated(since = "5.5.5", note = "text")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error[E0711]: feature `c` is declared stable, but was previously declared unstable
+  --> $DIR/stability-attribute-sanity.rs:57:1
+   |
+LL | #[stable(feature = "c", since = "4.4.4")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0711]: feature `a` is declared stable since 1.0.0, but was previously declared stable since 4.4.4
   --> $DIR/stability-attribute-sanity.rs:67:1
    |
 LL | #[stable(feature = "a", since = "1.0.0")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 20 previous errors
+error: aborting due to 21 previous errors
 
 Some errors have detailed explanations: E0539, E0541, E0542, E0543, E0544, E0546, E0547, E0549, E0711.
 For more information about an error, try `rustc --explain E0539`.