Expose FeatureGateSubdiagnostic struct instead of applying it opaquely

Author: Xiretza

compiler/rustc_ast_lowering/src/errors.rs

@@ -2,6 +2,7 @@ use rustc_errors::{
     codes::*, Diag, DiagArgFromDisplay, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic,
 };
 use rustc_macros::{Diagnostic, Subdiagnostic};
+use rustc_session::errors::FeatureGateSubdiagnostic;
 use rustc_span::{symbol::Ident, Span, Symbol};
 
 #[derive(Diagnostic)]
@@ -384,12 +385,16 @@ pub enum BadReturnTypeNotation {
         #[primary_span]
         #[suggestion(code = "()", applicability = "maybe-incorrect")]
         span: Span,
+        #[subdiagnostic]
+        subdiag: Option<FeatureGateSubdiagnostic>,
     },
     #[diag(ast_lowering_bad_return_type_notation_output)]
     Output {
         #[primary_span]
         #[suggestion(code = "", applicability = "maybe-incorrect")]
         span: Span,
+        #[subdiagnostic]
+        subdiag: Option<FeatureGateSubdiagnostic>,
     },
 }
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -62,7 +62,7 @@ use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
-use rustc_session::parse::{add_feature_diagnostics, feature_err};
+use rustc_session::parse::{feature_err, get_feature_diagnostics};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{DesugaringKind, Span, DUMMY_SP};
 use smallvec::{smallvec, SmallVec};
@@ -1005,27 +1005,29 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     } else if let Some(first_char) = constraint.ident.as_str().chars().next()
                         && first_char.is_ascii_lowercase()
                     {
-                        let mut err = if !data.inputs.is_empty() {
-                            self.dcx().create_err(errors::BadReturnTypeNotation::Inputs {
+                        let subdiag = if !self.tcx.features().return_type_notation
+                            && self.tcx.sess.is_nightly_build()
+                        {
+                            Some(get_feature_diagnostics(&self.tcx.sess, sym::return_type_notation))
+                        } else {
+                            None
+                        };
+
+                        let err = if !data.inputs.is_empty() {
+                            errors::BadReturnTypeNotation::Inputs {
                                 span: data.inputs_span,
-                            })
+                                subdiag,
+                            }
                         } else if let FnRetTy::Ty(ty) = &data.output {
-                            self.dcx().create_err(errors::BadReturnTypeNotation::Output {
+                            errors::BadReturnTypeNotation::Output {
                                 span: data.inputs_span.shrink_to_hi().to(ty.span),
-                            })
+                                subdiag,
+                            }
                         } else {
                             unreachable!("inputs are empty and return type is not provided")
                         };
-                        if !self.tcx.features().return_type_notation
-                            && self.tcx.sess.is_nightly_build()
-                        {
-                            add_feature_diagnostics(
-                                &mut err,
-                                &self.tcx.sess,
-                                sym::return_type_notation,
-                            );
-                        }
-                        err.emit();
+                        self.dcx().create_err(err).emit();
+
                         GenericArgsCtor {
                             args: Default::default(),
                             bindings: &[],

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -284,28 +284,28 @@ fn default_body_is_unstable(
         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,
+    let subdiag = rustc_session::parse::get_feature_diagnostics_for_issue(
         &tcx.sess,
         feature,
         rustc_feature::GateIssue::Library(issue),
         false,
         inject_span,
     );
 
-    err.emit();
+    tcx.dcx()
+        .create_err(errors::MissingTraitItemUnstable {
+            span: impl_span,
+            some_note,
+            none_note,
+            missing_item_name,
+            feature,
+            reason: reason_str,
+            subdiag,
+        })
+        .emit();
 }
 
 /// Re-sugar `ty::GenericPredicates` in a way suitable to be used in structured suggestions.

compiler/rustc_hir_analysis/src/errors.rs

@@ -6,6 +6,7 @@ use rustc_errors::{
 };
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::ty::Ty;
+use rustc_session::errors::FeatureGateSubdiagnostic;
 use rustc_span::{symbol::Ident, Span, Symbol};
 mod pattern_types;
 pub use pattern_types::*;
@@ -954,6 +955,8 @@ pub(crate) struct MissingTraitItemUnstable {
     pub some_note: bool,
     #[note(hir_analysis_none_note)]
     pub none_note: bool,
+    #[subdiagnostic]
+    pub subdiag: FeatureGateSubdiagnostic,
     pub missing_item_name: Symbol,
     pub feature: Symbol,
     pub reason: String,

compiler/rustc_lint/src/levels.rs

@@ -1072,13 +1072,15 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
                 |lint| {
                     lint.arg("name", lint_id.lint.name_lower());
                     lint.note(fluent::lint_note);
-                    rustc_session::parse::add_feature_diagnostics_for_issue(
-                        lint,
-                        &self.sess,
-                        feature,
-                        GateIssue::Language,
-                        lint_from_cli,
-                        None,
+                    lint.subdiagnostic(
+                        self.sess.dcx(),
+                        rustc_session::parse::get_feature_diagnostics_for_issue(
+                            &self.sess,
+                            feature,
+                            GateIssue::Language,
+                            lint_from_cli,
+                            None,
+                        ),
                     );
                 },
             );

compiler/rustc_lint/src/lints.rs

@@ -244,10 +244,9 @@ pub struct BuiltinUngatedAsyncFnTrackCaller<'a> {
 impl<'a> LintDiagnostic<'a, ()> for BuiltinUngatedAsyncFnTrackCaller<'_> {
     fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, ()>) {
         diag.span_label(self.label, fluent::lint_label);
-        rustc_session::parse::add_feature_diagnostics(
-            diag,
-            self.session,
-            sym::async_fn_track_caller,
+        diag.subdiagnostic(
+            self.session.dcx(),
+            rustc_session::parse::get_feature_diagnostics(self.session, sym::async_fn_track_caller),
         );
     }
 

compiler/rustc_session/src/errors.rs

@@ -12,15 +12,19 @@ use rustc_target::spec::{SplitDebuginfo, StackProtector, TargetTriple};
 
 use crate::{config::CrateType, parse::ParseSess};
 
+// FIXME: factor into separate structs to avoid dynamic DiagMessage field
 pub(crate) struct FeatureGateError {
     pub(crate) span: MultiSpan,
     pub(crate) explain: DiagMessage,
+    pub(crate) subdiag: FeatureGateSubdiagnostic,
 }
 
 impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for FeatureGateError {
     #[track_caller]
     fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
-        Diag::new(dcx, level, self.explain).with_span(self.span).with_code(E0658)
+        let mut diag = Diag::new(dcx, level, self.explain).with_span(self.span).with_code(E0658);
+        diag.subdiagnostic(dcx, self.subdiag);
+        diag
     }
 }
 

compiler/rustc_session/src/parse.rs

@@ -15,8 +15,7 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
 use rustc_data_structures::sync::{AppendOnlyVec, Lock, Lrc};
 use rustc_errors::emitter::{stderr_destination, HumanEmitter, SilentEmitter};
 use rustc_errors::{
-    fallback_fluent_bundle, ColorConfig, Diag, DiagCtxt, DiagMessage, EmissionGuarantee, MultiSpan,
-    StashKey,
+    fallback_fluent_bundle, ColorConfig, Diag, DiagCtxt, DiagMessage, MultiSpan, StashKey,
 };
 use rustc_feature::{find_feature_issue, GateIssue, UnstableFeatures};
 use rustc_span::edition::Edition;
@@ -111,9 +110,9 @@ pub fn feature_err_issue(
         }
     }
 
-    let mut err = sess.psess.dcx.create_err(FeatureGateError { span, explain: explain.into() });
-    add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
-    err
+    let subdiag = get_feature_diagnostics_for_issue(sess, feature, issue, false, None);
+
+    sess.psess.dcx.create_err(FeatureGateError { span, explain: explain.into(), subdiag })
 }
 
 /// Construct a future incompatibility diagnostic for a feature gate.
@@ -141,7 +140,10 @@ pub fn feature_warn_issue(
     explain: &'static str,
 ) {
     let mut err = sess.psess.dcx.struct_span_warn(span, explain);
-    add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
+    err.subdiagnostic(
+        sess.dcx(),
+        get_feature_diagnostics_for_issue(sess, feature, issue, false, None),
+    );
 
     // Decorate this as a future-incompatibility lint as in rustc_middle::lint::lint_level
     let lint = UNSTABLE_SYNTAX_PRE_EXPANSION;
@@ -154,29 +156,23 @@ pub fn feature_warn_issue(
     err.stash(span, StashKey::EarlySyntaxWarning);
 }
 
-/// Adds the diagnostics for a feature to an existing error.
-pub fn add_feature_diagnostics<G: EmissionGuarantee>(
-    err: &mut Diag<'_, G>,
-    sess: &Session,
-    feature: Symbol,
-) {
-    add_feature_diagnostics_for_issue(err, sess, feature, GateIssue::Language, false, None);
+/// Returns the subdiagnostics for a feature gate error.
+pub fn get_feature_diagnostics(sess: &Session, feature: Symbol) -> FeatureGateSubdiagnostic {
+    get_feature_diagnostics_for_issue(sess, feature, GateIssue::Language, false, None)
 }
 
-/// Adds the diagnostics for a feature to an existing error.
+/// Returns the subdiagnostics for a feature gate error.
 ///
 /// This variant allows you to control whether it is a library or language feature.
 /// Almost always, you want to use this for a language feature. If so, prefer
 /// `add_feature_diagnostics`.
-#[allow(rustc::diagnostic_outside_of_impl)] // FIXME
-pub fn add_feature_diagnostics_for_issue<G: EmissionGuarantee>(
-    err: &mut Diag<'_, G>,
+pub fn get_feature_diagnostics_for_issue(
     sess: &Session,
     feature: Symbol,
     issue: GateIssue,
     feature_from_cli: bool,
     inject_span: Option<Span>,
-) {
+) -> FeatureGateSubdiagnostic {
     let issue = find_feature_issue(feature, issue).map(|n| FeatureDiagnosticForIssue { n });
 
     // #23973: do not suggest `#![feature(...)]` if we are in beta/stable
@@ -200,9 +196,7 @@ pub fn add_feature_diagnostics_for_issue<G: EmissionGuarantee>(
         (None, None)
     };
 
-    let subdiagnostic = FeatureGateSubdiagnostic { issue, upgrade_compiler, enable_feature };
-
-    err.subdiagnostic(sess.dcx(), subdiagnostic);
+    FeatureGateSubdiagnostic { issue, upgrade_compiler, enable_feature }
 }
 
 /// Info about a parsing session.

compiler/rustc_session/src/session.rs

@@ -6,7 +6,7 @@ use crate::config::{
 };
 use crate::config::{ErrorOutputType, Input};
 use crate::errors;
-use crate::parse::{add_feature_diagnostics, ParseSess};
+use crate::parse::{get_feature_diagnostics, ParseSess};
 use crate::search_paths::{PathKind, SearchPath};
 use crate::{filesearch, lint};
 
@@ -301,13 +301,13 @@ impl Session {
     }
 
     #[track_caller]
+    #[allow(rustc::diagnostic_outside_of_impl)]
     pub fn create_feature_err<'a>(&'a self, err: impl Diagnostic<'a>, feature: Symbol) -> Diag<'a> {
         let mut err = self.dcx().create_err(err);
         if err.code.is_none() {
-            #[allow(rustc::diagnostic_outside_of_impl)]
             err.code(E0658);
         }
-        add_feature_diagnostics(&mut err, self, feature);
+        err.subdiagnostic(self.dcx(), get_feature_diagnostics(self, feature));
         err
     }
 

src/librustdoc/passes/check_custom_code_classes.rs

@@ -11,7 +11,7 @@ use crate::html::markdown::{find_codes, ErrorCodes, LangString};
 
 use rustc_errors::StashKey;
 use rustc_feature::GateIssue;
-use rustc_session::parse::add_feature_diagnostics_for_issue;
+use rustc_session::parse::get_feature_diagnostics_for_issue;
 use rustc_span::symbol::sym;
 
 pub(crate) const CHECK_CUSTOM_CODE_CLASSES: Pass = Pass {
@@ -69,13 +69,15 @@ pub(crate) fn look_for_custom_classes<'tcx>(cx: &DocContext<'tcx>, item: &Item)
         let mut err = sess
             .dcx()
             .struct_span_warn(span, "custom classes in code blocks will change behaviour");
-        add_feature_diagnostics_for_issue(
-            &mut err,
-            sess,
-            sym::custom_code_classes_in_docs,
-            GateIssue::Language,
-            false,
-            None,
+        err.subdiagnostic(
+            sess.dcx(),
+            get_feature_diagnostics_for_issue(
+                sess,
+                sym::custom_code_classes_in_docs,
+                GateIssue::Language,
+                false,
+                None,
+            ),
         );
 
         err.note(