Improve diagnostics for the use of unstable library features

- only emits one error/lint (instead of one per missing feature) per usage of unstable and
  body-unstable items
- only emits one future-name-collision lint (instead of one per missing feature) for unstable trait
  items
- makes diagnostics for unstable, soft-unstable, const-unstable, and body-unstable library features
  translatable, using common subdiagnostic structs.
- adds notes with features, reasons, and issue links to const-unstability errors
- adds notes with issue links to soft_unstable lints
- on nightly, adds `#![feature]` crate attr help to soft_unstable lints
- on nightly, adds compiler-upgrade-suggestion notes to const-unstable and soft_unstable diagnostics

Author: dianne

compiler/rustc_const_eval/messages.ftl

@@ -420,7 +420,6 @@ const_eval_unstable_in_stable_exposed =
     .bypass_sugg = otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval)
 
 const_eval_unstable_intrinsic = `{$name}` is not yet stable as a const intrinsic
-    .help = add `#![feature({$feature})]` to the crate attributes to enable
 
 const_eval_unterminated_c_string =
     reading a null-terminated string starting at {$pointer} with no null found before end of allocation

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -741,7 +741,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         }) => {
                             self.check_op(ops::IntrinsicUnstable {
                                 name: intrinsic.name,
-                                features: unstables.iter().map(|u| u.feature).collect(),
+                                features: unstables.iter().map(|u| u.into()).collect(),
                                 const_stable_indirect: *const_stable_indirect,
                             });
                         }
@@ -823,12 +823,12 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         // case we need `check_op` to do the check.
                         let danger_zone = !callee_safe_to_expose_on_stable
                             && self.enforce_recursive_const_stability();
-                        let missing_features: SmallVec<[Symbol; 1]> = if danger_zone {
-                            needs_check.map(|u| u.feature).collect()
+                        let missing_features: SmallVec<[_; 1]> = if danger_zone {
+                            needs_check.map(|u| u.into()).collect()
                         } else {
                             needs_check
                                 .filter(|u| !is_feature_enabled(u))
-                                .map(|u| u.feature)
+                                .map(|u| u.into())
                                 .collect()
                         };
                         if !missing_features.is_empty() {

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -8,6 +8,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::{ImplSource, Obligation, ObligationCause};
+use rustc_middle::middle::stability;
 use rustc_middle::mir::CallSource;
 use rustc_middle::span_bug;
 use rustc_middle::ty::print::{PrintTraitRefExt as _, with_no_trimmed_paths};
@@ -305,38 +306,37 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
 
 /// A call to an `#[unstable]` const fn or `#[rustc_const_unstable]` function.
 ///
-/// Contains the names of the features that would allow the use of this function.
+/// Contains the names of the features that would allow the use of this function,
+/// as well as an optional reason and github issue link for diagnostics.
 #[derive(Debug)]
 pub(crate) struct FnCallUnstable {
     pub def_id: DefId,
-    pub features: SmallVec<[Symbol; 1]>,
+    pub features: SmallVec<[stability::EvalDenial; 1]>,
     pub safe_to_expose_on_stable: bool,
 }
 
 impl<'tcx> NonConstOp<'tcx> for FnCallUnstable {
     fn status_in_item(&self, _ccx: &ConstCx<'_, 'tcx>) -> Status {
         Status::Unstable {
-            gates: self.features.clone(),
+            gates: self.features.iter().map(|d| d.feature).collect(),
             safe_to_expose_on_stable: self.safe_to_expose_on_stable,
             is_function_call: true,
         }
     }
 
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        let mut err = ccx.dcx().create_err(errors::UnstableConstFn {
+        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),
-        });
-        // FIXME: make this translatable
-        #[allow(rustc::untranslatable_diagnostic)]
-        if ccx.tcx.sess.is_nightly_build() {
-            err.help(format!(
-                "add `#![feature({})]` to the crate attributes to enable",
-                self.features.iter().map(Symbol::as_str).intersperse(", ").collect::<String>(),
-            ));
-        }
-
-        err
+            features,
+            info,
+            nightly_subdiags,
+        })
     }
 }
 
@@ -356,18 +356,18 @@ impl<'tcx> NonConstOp<'tcx> for IntrinsicNonConst {
     }
 }
 
-/// A call to an intrinsic that is just not const-callable at all.
+/// A call to an intrinsic that is const-unstable.
 #[derive(Debug)]
 pub(crate) struct IntrinsicUnstable {
     pub name: Symbol,
-    pub features: SmallVec<[Symbol; 1]>,
+    pub features: SmallVec<[stability::EvalDenial; 1]>,
     pub const_stable_indirect: bool,
 }
 
 impl<'tcx> NonConstOp<'tcx> for IntrinsicUnstable {
     fn status_in_item(&self, _ccx: &ConstCx<'_, 'tcx>) -> Status {
         Status::Unstable {
-            gates: self.features.clone(),
+            gates: self.features.iter().map(|d| d.feature).collect(),
             safe_to_expose_on_stable: self.const_stable_indirect,
             // We do *not* want to suggest to mark the intrinsic as `const_stable_indirect`,
             // that's not a trivial change!
@@ -376,10 +376,17 @@ 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,
-            feature: self.features.iter().map(Symbol::as_str).intersperse(", ").collect(),
+            features,
+            info,
+            nightly_subdiags,
         })
     }
 }

compiler/rustc_const_eval/src/errors.rs

@@ -119,16 +119,26 @@ pub(crate) struct UnstableConstFn {
     #[primary_span]
     pub span: Span,
     pub def_path: String,
+    #[subdiagnostic]
+    pub features: rustc_middle::error::UnstableLibraryFeatureNote,
+    #[subdiagnostic]
+    pub info: Vec<rustc_middle::error::UnstableLibraryFeatureInfo>,
+    #[subdiagnostic]
+    pub nightly_subdiags: Vec<rustc_session::errors::NightlyFeatureDiagnostic>,
 }
 
 #[derive(Diagnostic)]
 #[diag(const_eval_unstable_intrinsic)]
-#[help]
 pub(crate) struct UnstableIntrinsic {
     #[primary_span]
     pub span: Span,
     pub name: Symbol,
-    pub feature: String,
+    #[subdiagnostic]
+    pub features: rustc_middle::error::UnstableLibraryFeatureNote,
+    #[subdiagnostic]
+    pub info: Vec<rustc_middle::error::UnstableLibraryFeatureInfo>,
+    #[subdiagnostic]
+    pub nightly_subdiags: Vec<rustc_session::errors::NightlyFeatureDiagnostic>,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_hir_analysis/messages.ftl

@@ -309,8 +309,6 @@ hir_analysis_missing_trait_item_suggestion = implement the missing item: `{$snip
 
 hir_analysis_missing_trait_item_unstable = not all trait items implemented, missing: `{$missing_item_name}`
     .note = default implementation of `{$missing_item_name}` is unstable
-    .some_note = use of unstable library feature `{$feature}`: {$reason}
-    .none_note = use of unstable library feature `{$feature}`
 
 hir_analysis_missing_type_params =
     the type {$parameterCount ->

compiler/rustc_hir_analysis/src/check/check.rs

@@ -922,14 +922,7 @@ fn check_impl_items_against_trait<'tcx>(
                 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, .. } => {
-                        for denial in denials {
-                            default_body_is_unstable(
-                                tcx,
-                                full_impl_span,
-                                trait_item_id,
-                                denial.unstability,
-                            );
-                        }
+                        default_body_is_unstable(tcx, full_impl_span, trait_item_id, &denials);
                     }
 
                     // Unmarked default bodies are considered stable (at least for now).

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -80,6 +80,7 @@ use rustc_index::bit_set::BitSet;
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::infer::{self, TyCtxtInferExt as _};
 use rustc_infer::traits::ObligationCause;
+use rustc_middle::middle::stability;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::{self, GenericArgs, GenericArgsRef, Ty, TyCtxt};
@@ -293,41 +294,22 @@ fn default_body_is_unstable(
     tcx: TyCtxt<'_>,
     impl_span: Span,
     item_did: DefId,
-    unstability: rustc_attr::Unstability,
+    denials: &[stability::EvalDenial],
 ) {
-    let rustc_attr::Unstability { feature, reason, issue, .. } = unstability;
     let missing_item_name = tcx.associated_item(item_did).name;
-    let (mut some_note, mut none_note, mut reason_str) = (false, false, String::new());
-    match reason.to_opt_reason() {
-        Some(r) => {
-            some_note = true;
-            reason_str = r.to_string();
-        }
-        None => none_note = true,
-    };
-
-    let mut err = tcx.dcx().create_err(errors::MissingTraitItemUnstable {
-        span: impl_span,
-        some_note,
-        none_note,
-        missing_item_name,
-        feature,
-        reason: reason_str,
-    });
-
     let inject_span = item_did
         .as_local()
         .and_then(|id| tcx.crate_level_attribute_injection_span(tcx.local_def_id_to_hir_id(id)));
-    rustc_session::parse::add_feature_diagnostics_for_issue(
-        &mut err,
-        &tcx.sess,
-        feature,
-        rustc_feature::GateIssue::Library(issue),
-        false,
-        inject_span,
-    );
+    let (features, info) = stability::unstable_notes(denials);
+    let nightly_subdiags = stability::unstable_nightly_subdiags(&tcx.sess, denials, inject_span);
 
-    err.emit();
+    tcx.dcx().emit_err(errors::MissingTraitItemUnstable {
+        span: impl_span,
+        missing_item_name,
+        features,
+        info,
+        nightly_subdiags,
+    });
 }
 
 /// Re-sugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.

compiler/rustc_hir_analysis/src/errors.rs

@@ -977,13 +977,13 @@ pub(crate) struct MissingOneOfTraitItem {
 pub(crate) struct MissingTraitItemUnstable {
     #[primary_span]
     pub span: Span,
-    #[note(hir_analysis_some_note)]
-    pub some_note: bool,
-    #[note(hir_analysis_none_note)]
-    pub none_note: bool,
     pub missing_item_name: Symbol,
-    pub feature: Symbol,
-    pub reason: String,
+    #[subdiagnostic]
+    pub features: rustc_middle::error::UnstableLibraryFeatureNote,
+    #[subdiagnostic]
+    pub info: Vec<rustc_middle::error::UnstableLibraryFeatureInfo>,
+    #[subdiagnostic]
+    pub nightly_subdiags: Vec<rustc_session::errors::NightlyFeatureDiagnostic>,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_hir_typeck/src/lib.rs

@@ -4,6 +4,7 @@
 #![feature(array_windows)]
 #![feature(box_patterns)]
 #![feature(if_let_guard)]
+#![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(never_type)]
 #![feature(try_blocks)]

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -1327,10 +1327,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 if let stability::EvalResult::Deny { denials, .. } =
                     self.tcx.eval_stability(candidate.item.def_id, None, self.span, None)
                 {
-                    uc.push((
-                        candidate.clone(),
-                        denials.iter().map(|d| d.unstability.feature).collect(),
-                    ));
+                    uc.push((candidate.clone(), denials.iter().map(|d| d.feature).collect()));
                     return false;
                 }
                 true
@@ -1429,10 +1426,11 @@ impl<'tcx> Pick<'tcx> {
             tcx.disabled_nightly_features(
                 lint,
                 Some(scope_expr_id),
-                self.unstable_candidates.iter().flat_map(|(candidate, features)| {
-                    features.iter().map(|feature| {
-                        (format!(" `{}`", tcx.def_path_str(candidate.item.def_id)), *feature)
-                    })
+                self.unstable_candidates.iter().map(|(candidate, features)| {
+                    (
+                        format!(" `{}`", tcx.def_path_str(candidate.item.def_id)),
+                        features.iter().map(Symbol::as_str).intersperse(", ").collect::<String>(),
+                    )
                 }),
             );
         });