rustc_session: turn feature gate subdiagnostic into struct

Author: Xiretza

compiler/rustc_session/src/errors.rs

@@ -4,7 +4,7 @@ use rustc_ast::token;
 use rustc_ast::util::literal::LitError;
 use rustc_errors::{
     codes::*, Diag, DiagCtxt, DiagMessage, Diagnostic, EmissionGuarantee, ErrorGuaranteed, Level,
-    MultiSpan,
+    MultiSpan, Subdiagnostic,
 };
 use rustc_macros::Diagnostic;
 use rustc_span::{Span, Symbol};
@@ -24,6 +24,30 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for FeatureGateError {
     }
 }
 
+pub struct FeatureGateSubdiagnostic {
+    pub(crate) issue: Option<FeatureDiagnosticForIssue>,
+    pub(crate) enable_feature: Option<EnableFeatureSubdiagnostic>,
+    pub(crate) upgrade_compiler: Option<SuggestUpgradeCompiler>,
+}
+
+impl Subdiagnostic for FeatureGateSubdiagnostic {
+    fn add_to_diag_with<G: EmissionGuarantee, F: rustc_errors::SubdiagMessageOp<G>>(
+        self,
+        diag: &mut Diag<'_, G>,
+        f: F,
+    ) {
+        if let Some(issue) = self.issue {
+            issue.add_to_diag_with(diag, |diag, msg| f(diag, msg));
+        }
+        if let Some(enable_feature) = self.enable_feature {
+            enable_feature.add_to_diag_with(diag, |diag, msg| f(diag, msg));
+        }
+        if let Some(upgrade_compiler) = self.upgrade_compiler {
+            upgrade_compiler.add_to_diag_with(diag, |diag, msg| f(diag, msg));
+        }
+    }
+}
+
 #[derive(Subdiagnostic)]
 #[note(session_feature_diagnostic_for_issue)]
 pub(crate) struct FeatureDiagnosticForIssue {
@@ -49,27 +73,21 @@ impl SuggestUpgradeCompiler {
 }
 
 #[derive(Subdiagnostic)]
-#[help(session_feature_diagnostic_help)]
-pub(crate) struct FeatureDiagnosticHelp {
-    pub(crate) feature: Symbol,
-}
-
-#[derive(Subdiagnostic)]
-#[suggestion(
-    session_feature_diagnostic_suggestion,
-    applicability = "maybe-incorrect",
-    code = "#![feature({feature})]\n"
-)]
-pub struct FeatureDiagnosticSuggestion {
-    pub feature: Symbol,
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(Subdiagnostic)]
-#[help(session_cli_feature_diagnostic_help)]
-pub(crate) struct CliFeatureDiagnosticHelp {
-    pub(crate) feature: Symbol,
+pub(crate) enum EnableFeatureSubdiagnostic {
+    #[help(session_feature_diagnostic_help)]
+    AddAttrHelp { feature: Symbol },
+    #[suggestion(
+        session_feature_diagnostic_suggestion,
+        applicability = "maybe-incorrect",
+        code = "#![feature({feature})]\n"
+    )]
+    AddAttrSuggestion {
+        feature: Symbol,
+        #[primary_span]
+        span: Span,
+    },
+    #[help(session_cli_feature_diagnostic_help)]
+    AddCliHelp { feature: Symbol },
 }
 
 #[derive(Diagnostic)]

compiler/rustc_session/src/parse.rs

@@ -3,8 +3,8 @@
 
 use crate::config::{Cfg, CheckCfg};
 use crate::errors::{
-    CliFeatureDiagnosticHelp, FeatureDiagnosticForIssue, FeatureDiagnosticHelp,
-    FeatureDiagnosticSuggestion, FeatureGateError, SuggestUpgradeCompiler,
+    EnableFeatureSubdiagnostic, FeatureDiagnosticForIssue, FeatureGateError,
+    FeatureGateSubdiagnostic, SuggestUpgradeCompiler,
 };
 use crate::lint::{
     builtin::UNSTABLE_SYNTAX_PRE_EXPANSION, BufferedEarlyLint, BuiltinLintDiag, Lint, LintId,
@@ -177,26 +177,32 @@ pub fn add_feature_diagnostics_for_issue<G: EmissionGuarantee>(
     feature_from_cli: bool,
     inject_span: Option<Span>,
 ) {
-    if let Some(n) = find_feature_issue(feature, issue) {
-        err.subdiagnostic(sess.dcx(), FeatureDiagnosticForIssue { n });
-    }
+    let issue = find_feature_issue(feature, issue).map(|n| FeatureDiagnosticForIssue { n });
 
     // #23973: do not suggest `#![feature(...)]` if we are in beta/stable
-    if sess.psess.unstable_features.is_nightly_build() {
-        if feature_from_cli {
-            err.subdiagnostic(sess.dcx(), CliFeatureDiagnosticHelp { feature });
+    let (enable_feature, upgrade_compiler) = if sess.psess.unstable_features.is_nightly_build() {
+        let enable_feature = if feature_from_cli {
+            EnableFeatureSubdiagnostic::AddCliHelp { feature }
         } else if let Some(span) = inject_span {
-            err.subdiagnostic(sess.dcx(), FeatureDiagnosticSuggestion { feature, span });
+            EnableFeatureSubdiagnostic::AddAttrSuggestion { feature, span }
         } else {
-            err.subdiagnostic(sess.dcx(), FeatureDiagnosticHelp { feature });
-        }
+            EnableFeatureSubdiagnostic::AddAttrHelp { feature }
+        };
 
-        if sess.opts.unstable_opts.ui_testing {
-            err.subdiagnostic(sess.dcx(), SuggestUpgradeCompiler::ui_testing());
-        } else if let Some(suggestion) = SuggestUpgradeCompiler::new() {
-            err.subdiagnostic(sess.dcx(), suggestion);
-        }
-    }
+        let upgrade_compiler = if sess.opts.unstable_opts.ui_testing {
+            Some(SuggestUpgradeCompiler::ui_testing())
+        } else {
+            SuggestUpgradeCompiler::new()
+        };
+
+        (Some(enable_feature), upgrade_compiler)
+    } else {
+        (None, None)
+    };
+
+    let subdiagnostic = FeatureGateSubdiagnostic { issue, upgrade_compiler, enable_feature };
+
+    err.subdiagnostic(sess.dcx(), subdiagnostic);
 }
 
 /// Info about a parsing session.