Simplify unstable language feature use diagnostics

Reasons provided on `#[unstable]` attributes are now per-item rather than
per-feature. This is how they mostly are used anyway, and it simplifies both
the implementation and the diagnostics themselves.

Author: dianne

compiler/rustc_attr/messages.ftl

@@ -85,6 +85,9 @@ attr_multiple_item =
 attr_multiple_stability_levels =
     multiple stability levels for feature `{$feature}`
 
+attr_multiple_unstable_reasons =
+    multiple reasons provided for unstability
+
 attr_non_ident_feature =
     'feature' is not an identifier
 

compiler/rustc_attr/src/builtin.rs

@@ -137,8 +137,10 @@ pub struct DefaultBodyStability {
 pub enum StabilityLevel {
     /// `#[unstable]`
     Unstable {
-        /// The information unique to each `#[unstable]` attribute
+        /// The feature and optional github issue for each `#[unstable]` attribute
         unstables: SmallVec<[Unstability; 1]>,
+        /// Reason for the current stability level.
+        reason: UnstableReason,
         is_soft: bool,
     },
     /// `#[stable]`
@@ -159,7 +161,12 @@ pub enum ConstStabilityLevel {
     /// For functions declared const-stable
     Stable { since: StableSince },
     /// For functions declared const-unstable
-    Unstable { unstables: SmallVec<[Unstability; 1]> },
+    Unstable {
+        /// The feature and optional github issue for each `#[rustc_const_unstable]` attribute
+        unstables: SmallVec<[Unstability; 1]>,
+        /// Reason for the current stability level.
+        reason: UnstableReason,
+    },
     /// 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.
     Implicit,
@@ -207,8 +214,8 @@ impl StabilityLevel {
 
     fn to_const_stab_level(self) -> ConstStabilityLevel {
         match self {
-            StabilityLevel::Unstable { unstables, .. } => {
-                ConstStabilityLevel::Unstable { unstables }
+            StabilityLevel::Unstable { unstables, reason, .. } => {
+                ConstStabilityLevel::Unstable { unstables, reason }
             }
             StabilityLevel::Stable { since, .. } => ConstStabilityLevel::Stable { since },
         }
@@ -247,8 +254,6 @@ impl ConstStabilityLevel {
 #[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,
@@ -486,10 +491,18 @@ fn add_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 },
+            Some(Unstable { unstables, reason, is_soft }),
+            Unstable { unstables: new_unstable, reason: new_reason, is_soft: new_soft },
         ) => {
             unstables.extend(new_unstable);
+            match (reason, new_reason) {
+                (_, UnstableReason::None) => {}
+                (reason @ UnstableReason::None, _) => *reason = new_reason,
+                _ => {
+                    sess.dcx()
+                        .emit_err(session_diagnostics::MultipleUnstableReasons { span: attr.span });
+                }
+            }
             // 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?
@@ -670,13 +683,12 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
 
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
-            let unstability = Unstability {
-                feature,
+            let unstability = Unstability { feature, issue: issue_num, implied_by };
+            Some((feature, StabilityLevel::Unstable {
+                unstables: smallvec![unstability],
                 reason: UnstableReason::from_opt_reason(reason),
-                issue: issue_num,
-                implied_by,
-            };
-            Some((feature, StabilityLevel::Unstable { unstables: smallvec![unstability], is_soft }))
+                is_soft,
+            }))
         }
         (Err(ErrorGuaranteed { .. }), _) | (_, Err(ErrorGuaranteed { .. })) => None,
     }

compiler/rustc_attr/src/session_diagnostics.rs

@@ -83,6 +83,13 @@ pub(crate) struct MultipleStabilityLevels {
     pub feature: Symbol,
 }
 
+#[derive(Diagnostic)]
+#[diag(attr_multiple_unstable_reasons)]
+pub(crate) struct MultipleUnstableReasons {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(attr_invalid_issue_string, code = E0545)]
 pub(crate) struct InvalidIssueString {

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -735,13 +735,14 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             }
                         }
                         Some(ConstStability {
-                            level: ConstStabilityLevel::Unstable { unstables },
+                            level: ConstStabilityLevel::Unstable { unstables, reason },
                             const_stable_indirect,
                             ..
                         }) => {
                             self.check_op(ops::IntrinsicUnstable {
                                 name: intrinsic.name,
                                 features: unstables.iter().map(|u| u.into()).collect(),
+                                reason: *reason,
                                 const_stable_indirect: *const_stable_indirect,
                             });
                         }
@@ -789,7 +790,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         }
                     }
                     Some(ConstStability {
-                        level: ConstStabilityLevel::Unstable { unstables },
+                        level: ConstStabilityLevel::Unstable { unstables, reason },
                         ..
                     }) => {
                         // An unstable const fn with feature gates.
@@ -835,6 +836,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             self.check_op(ops::FnCallUnstable {
                                 def_id: callee,
                                 features: missing_features,
+                                reason: *reason,
                                 safe_to_expose_on_stable: callee_safe_to_expose_on_stable,
                             });
                         }

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -312,6 +312,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
 pub(crate) struct FnCallUnstable {
     pub def_id: DefId,
     pub features: SmallVec<[stability::EvalDenial; 1]>,
+    pub reason: rustc_attr::UnstableReason,
     pub safe_to_expose_on_stable: bool,
 }
 
@@ -325,17 +326,16 @@ impl<'tcx> NonConstOp<'tcx> for FnCallUnstable {
     }
 
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        let (features, info) = stability::unstable_notes(&self.features);
-        // Only suggest adding `#![feature]` on nightly.
-        let nightly_subdiags =
-            stability::unstable_nightly_subdiags(&ccx.tcx.sess, &self.features, None);
-
         ccx.dcx().create_err(errors::UnstableConstFn {
             span,
             def_path: ccx.tcx.def_path_str(self.def_id),
-            features,
-            info,
-            nightly_subdiags,
+            features: stability::unstable_message(&self.features, self.reason.to_opt_reason()),
+            issues: stability::unstable_issues(&self.features),
+            nightly_subdiags: stability::unstable_nightly_subdiags(
+                &ccx.tcx.sess,
+                &self.features,
+                None,
+            ),
         })
     }
 }
@@ -361,6 +361,7 @@ impl<'tcx> NonConstOp<'tcx> for IntrinsicNonConst {
 pub(crate) struct IntrinsicUnstable {
     pub name: Symbol,
     pub features: SmallVec<[stability::EvalDenial; 1]>,
+    pub reason: rustc_attr::UnstableReason,
     pub const_stable_indirect: bool,
 }
 
@@ -376,17 +377,16 @@ impl<'tcx> NonConstOp<'tcx> for IntrinsicUnstable {
     }
 
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        let (features, info) = stability::unstable_notes(&self.features);
-        // Only suggest adding `#![feature]` on nightly.
-        let nightly_subdiags =
-            stability::unstable_nightly_subdiags(&ccx.tcx.sess, &self.features, None);
-
         ccx.dcx().create_err(errors::UnstableIntrinsic {
             span,
             name: self.name,
-            features,
-            info,
-            nightly_subdiags,
+            features: stability::unstable_message(&self.features, self.reason.to_opt_reason()),
+            issues: stability::unstable_issues(&self.features),
+            nightly_subdiags: stability::unstable_nightly_subdiags(
+                &ccx.tcx.sess,
+                &self.features,
+                None,
+            ),
         })
     }
 }

compiler/rustc_const_eval/src/errors.rs

@@ -122,7 +122,7 @@ pub(crate) struct UnstableConstFn {
     #[subdiagnostic]
     pub features: rustc_middle::error::UnstableLibraryFeatureNote,
     #[subdiagnostic]
-    pub info: Vec<rustc_middle::error::UnstableLibraryFeatureInfo>,
+    pub issues: Vec<rustc_middle::error::UnstableLibraryFeatureIssue>,
     #[subdiagnostic]
     pub nightly_subdiags: Vec<rustc_session::errors::NightlyFeatureDiagnostic>,
 }
@@ -136,7 +136,7 @@ pub(crate) struct UnstableIntrinsic {
     #[subdiagnostic]
     pub features: rustc_middle::error::UnstableLibraryFeatureNote,
     #[subdiagnostic]
-    pub info: Vec<rustc_middle::error::UnstableLibraryFeatureInfo>,
+    pub issues: Vec<rustc_middle::error::UnstableLibraryFeatureIssue>,
     #[subdiagnostic]
     pub nightly_subdiags: Vec<rustc_session::errors::NightlyFeatureDiagnostic>,
 }

compiler/rustc_hir_analysis/src/check/check.rs

@@ -921,8 +921,14 @@ fn check_impl_items_against_trait<'tcx>(
             if !is_implemented_here {
                 let full_impl_span = tcx.hir().span_with_body(tcx.local_def_id_to_hir_id(impl_id));
                 match tcx.eval_default_body_stability(trait_item_id, full_impl_span) {
-                    EvalResult::Deny { denials, .. } => {
-                        default_body_is_unstable(tcx, full_impl_span, trait_item_id, &denials);
+                    EvalResult::Deny { denials, reason, .. } => {
+                        default_body_is_unstable(
+                            tcx,
+                            full_impl_span,
+                            trait_item_id,
+                            &denials,
+                            reason,
+                        );
                     }
 
                     // Unmarked default bodies are considered stable (at least for now).

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -88,7 +88,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::parse::feature_err;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::symbol::{Ident, kw, sym};
-use rustc_span::{BytePos, DUMMY_SP, Span};
+use rustc_span::{BytePos, DUMMY_SP, Span, Symbol};
 use rustc_target::abi::VariantIdx;
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
@@ -295,20 +295,19 @@ fn default_body_is_unstable(
     impl_span: Span,
     item_did: DefId,
     denials: &[stability::EvalDenial],
+    reason: Option<Symbol>,
 ) {
     let missing_item_name = tcx.associated_item(item_did).name;
     let inject_span = item_did
         .as_local()
         .and_then(|id| tcx.crate_level_attribute_injection_span(tcx.local_def_id_to_hir_id(id)));
-    let (features, info) = stability::unstable_notes(denials);
-    let nightly_subdiags = stability::unstable_nightly_subdiags(&tcx.sess, denials, inject_span);
 
     tcx.dcx().emit_err(errors::MissingTraitItemUnstable {
         span: impl_span,
         missing_item_name,
-        features,
-        info,
-        nightly_subdiags,
+        features: stability::unstable_message(denials, reason),
+        issues: stability::unstable_issues(denials),
+        nightly_subdiags: stability::unstable_nightly_subdiags(&tcx.sess, denials, inject_span),
     });
 }
 

compiler/rustc_hir_analysis/src/errors.rs

@@ -981,7 +981,7 @@ pub(crate) struct MissingTraitItemUnstable {
     #[subdiagnostic]
     pub features: rustc_middle::error::UnstableLibraryFeatureNote,
     #[subdiagnostic]
-    pub info: Vec<rustc_middle::error::UnstableLibraryFeatureInfo>,
+    pub issues: Vec<rustc_middle::error::UnstableLibraryFeatureIssue>,
     #[subdiagnostic]
     pub nightly_subdiags: Vec<rustc_session::errors::NightlyFeatureDiagnostic>,
 }

compiler/rustc_lint/src/context/diagnostics.rs

@@ -382,12 +382,12 @@ pub(super) fn decorate_lint(sess: &Session, diagnostic: BuiltinLintDiag, diag: &
         BuiltinLintDiag::MacroRuleNeverUsed(n, name) => {
             lints::MacroRuleNeverUsed { n: n + 1, name }.decorate_lint(diag);
         }
-        BuiltinLintDiag::SoftUnstableMacro { features } => {
+        BuiltinLintDiag::SoftUnstableMacro { features, reason } => {
             let denials = features
                 .iter()
-                .map(|&(feature, reason, issue)| stability::EvalDenial { feature, reason, issue })
+                .map(|&(feature, issue)| stability::EvalDenial { feature, issue })
                 .collect::<Vec<_>>();
-            stability::soft_unstable(sess, &denials, vec![]).decorate_lint(diag);
+            stability::soft_unstable(sess, &denials, reason, vec![]).decorate_lint(diag);
         }
         BuiltinLintDiag::AvoidUsingIntelSyntax => {
             lints::AvoidIntelSyntax.decorate_lint(diag);