Allow multiple unstable features in diagnostics

Author: dianne

Cargo.lock

@@ -3683,6 +3683,7 @@ dependencies = [
 name = "rustc_feature"
 version = "0.0.0"
 dependencies = [
+ "either",
  "rustc_data_structures",
  "rustc_span",
 ]

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,9 +1,9 @@
 use rustc_ast as ast;
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
 use rustc_ast::{NodeId, PatKind, attr, token};
-use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features, GateIssue};
+use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features};
 use rustc_session::Session;
-use rustc_session::parse::{feature_err, feature_err_issue, feature_warn};
+use rustc_session::parse::{feature_err, feature_warn};
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::sym;
 use rustc_span::{Span, Symbol};
@@ -81,7 +81,7 @@ impl<'a> PostExpansionVisitor<'a> {
         match abi::is_enabled(self.features, span, symbol_unescaped.as_str()) {
             Ok(()) => (),
             Err(abi::AbiDisabled::Unstable { feature, explain }) => {
-                feature_err_issue(&self.sess, feature, span, GateIssue::Language, explain).emit();
+                feature_err(&self.sess, feature, span, explain).emit();
             }
             Err(abi::AbiDisabled::Unrecognized) => {
                 if self.sess.opts.pretty.map_or(true, |ppm| ppm.needs_hir()) {

compiler/rustc_feature/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 # tidy-alphabetical-start
+either = "1.5.0"
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_span = { path = "../rustc_span" }
 # tidy-alphabetical-end

compiler/rustc_feature/src/lib.rs

@@ -97,7 +97,7 @@ impl UnstableFeatures {
     }
 }
 
-fn find_lang_feature_issue(feature: Symbol) -> Option<NonZero<u32>> {
+pub fn find_lang_feature_issue(feature: Symbol) -> Option<NonZero<u32>> {
     // Search in all the feature lists.
     if let Some(f) = UNSTABLE_LANG_FEATURES.iter().find(|f| f.name == feature) {
         return f.issue;
@@ -120,15 +120,21 @@ const fn to_nonzero(n: Option<u32>) -> Option<NonZero<u32>> {
     }
 }
 
-pub enum GateIssue {
+pub enum GateIssues {
     Language,
-    Library(Option<NonZero<u32>>),
+    Library(Vec<NonZero<u32>>),
 }
 
-pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u32>> {
-    match issue {
-        GateIssue::Language => find_lang_feature_issue(feature),
-        GateIssue::Library(lib) => lib,
+pub fn find_feature_issues(
+    features: &[Symbol],
+    issues: GateIssues,
+) -> impl Iterator<Item = NonZero<u32>> + use<'_> {
+    use either::{Left, Right};
+    match issues {
+        GateIssues::Language => {
+            Left(features.iter().flat_map(|&feature| find_lang_feature_issue(feature)))
+        }
+        GateIssues::Library(lib) => Right(lib.into_iter()),
     }
 }
 

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -320,11 +320,11 @@ fn default_body_is_unstable(
     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(
+    rustc_session::parse::add_feature_diagnostics_for_issues(
         &mut err,
         &tcx.sess,
-        feature,
-        rustc_feature::GateIssue::Library(issue),
+        &[feature],
+        rustc_feature::GateIssues::Library(Vec::from_iter(issue)),
         false,
         inject_span,
     );

compiler/rustc_lint/src/builtin.rs

@@ -22,7 +22,7 @@ use rustc_ast::visit::{FnCtxt, FnKind};
 use rustc_ast::{self as ast, *};
 use rustc_ast_pretty::pprust::{self, expr_to_string};
 use rustc_errors::{Applicability, LintDiagnostic};
-use rustc_feature::{AttributeGate, BuiltinAttribute, GateIssue, Stability, deprecated_attributes};
+use rustc_feature::{AttributeGate, BuiltinAttribute, Stability, deprecated_attributes};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
@@ -2313,7 +2313,7 @@ impl EarlyLintPass for IncompleteInternalFeatures {
             .filter(|(name, _)| features.incomplete(*name) || features.internal(*name))
             .for_each(|(name, span)| {
                 if features.incomplete(name) {
-                    let note = rustc_feature::find_feature_issue(name, GateIssue::Language)
+                    let note = rustc_feature::find_lang_feature_issue(name)
                         .map(|n| BuiltinFeatureIssueNote { n });
                     let help =
                         HAS_MIN_FEATURES.contains(&name).then_some(BuiltinIncompleteFeaturesHelp);

compiler/rustc_lint/src/levels.rs

@@ -1,7 +1,7 @@
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::{Diag, LintDiagnostic, MultiSpan};
-use rustc_feature::{Features, GateIssue};
+use rustc_feature::{Features, GateIssues};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{CRATE_HIR_ID, HirId};
 use rustc_index::IndexVec;
@@ -985,11 +985,11 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
                 lint.primary_message(fluent::lint_unknown_gated_lint);
                 lint.arg("name", lint_id.lint.name_lower());
                 lint.note(fluent::lint_note);
-                rustc_session::parse::add_feature_diagnostics_for_issue(
+                rustc_session::parse::add_feature_diagnostics_for_issues(
                     lint,
                     &self.sess,
-                    feature,
-                    GateIssue::Language,
+                    &[feature],
+                    GateIssues::Language,
                     lint_from_cli,
                     None,
                 );

compiler/rustc_middle/src/middle/stability.rs

@@ -9,15 +9,15 @@ use rustc_attr::{
 };
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::{Applicability, Diag, EmissionGuarantee};
-use rustc_feature::GateIssue;
+use rustc_feature::GateIssues;
 use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdMap};
 use rustc_hir::{self as hir, HirId};
 use rustc_macros::{Decodable, Encodable, HashStable, Subdiagnostic};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::Session;
 use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE, SOFT_UNSTABLE};
 use rustc_session::lint::{BuiltinLintDiag, DeprecatedSinceKind, Level, Lint, LintBuffer};
-use rustc_session::parse::feature_err_issue;
+use rustc_session::parse::feature_err_issues;
 use rustc_span::Span;
 use rustc_span::symbol::{Symbol, sym};
 use tracing::debug;
@@ -118,7 +118,8 @@ pub fn report_unstable(
     if is_soft {
         soft_handler(SOFT_UNSTABLE, span, msg)
     } else {
-        let mut err = feature_err_issue(sess, feature, span, GateIssue::Library(issue), msg);
+        let issues = Vec::from_iter(issue);
+        let mut err = feature_err_issues(sess, &[feature], span, GateIssues::Library(issues), msg);
         if let Some((inner_types, msg, sugg, applicability)) = suggestion {
             err.span_suggestion(inner_types, msg, sugg, applicability);
         }

compiler/rustc_session/src/errors.rs

@@ -53,7 +53,7 @@ impl SuggestUpgradeCompiler {
 #[derive(Subdiagnostic)]
 #[help(session_feature_diagnostic_help)]
 pub(crate) struct FeatureDiagnosticHelp {
-    pub(crate) feature: Symbol,
+    pub(crate) feature: String,
 }
 
 #[derive(Subdiagnostic)]
@@ -63,15 +63,15 @@ pub(crate) struct FeatureDiagnosticHelp {
     code = "#![feature({feature})]\n"
 )]
 pub struct FeatureDiagnosticSuggestion {
-    pub feature: Symbol,
+    pub feature: String,
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Subdiagnostic)]
 #[help(session_cli_feature_diagnostic_help)]
 pub(crate) struct CliFeatureDiagnosticHelp {
-    pub(crate) feature: Symbol,
+    pub(crate) feature: String,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_session/src/parse.rs

@@ -12,7 +12,7 @@ use rustc_errors::{
     ColorConfig, Diag, DiagCtxt, DiagCtxtHandle, DiagMessage, EmissionGuarantee, MultiSpan,
     StashKey, fallback_fluent_bundle,
 };
-use rustc_feature::{GateIssue, UnstableFeatures, find_feature_issue};
+use rustc_feature::{GateIssues, UnstableFeatures, find_feature_issues};
 use rustc_span::edition::Edition;
 use rustc_span::hygiene::ExpnId;
 use rustc_span::source_map::{FilePathMapping, SourceMap};
@@ -87,21 +87,21 @@ pub fn feature_err(
     span: impl Into<MultiSpan>,
     explain: impl Into<DiagMessage>,
 ) -> Diag<'_> {
-    feature_err_issue(sess, feature, span, GateIssue::Language, explain)
+    feature_err_issues(sess, &[feature], span, GateIssues::Language, explain)
 }
 
 /// Construct a diagnostic 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 `feature_err`.
 #[track_caller]
-pub fn feature_err_issue(
-    sess: &Session,
-    feature: Symbol,
+pub fn feature_err_issues<'a>(
+    sess: &'a Session,
+    features: &[Symbol],
     span: impl Into<MultiSpan>,
-    issue: GateIssue,
+    issues: GateIssues,
     explain: impl Into<DiagMessage>,
-) -> Diag<'_> {
+) -> Diag<'a> {
     let span = span.into();
 
     // Cancel an earlier warning for this same error, if it exists.
@@ -112,7 +112,7 @@ pub fn feature_err_issue(
     }
 
     let mut err = sess.dcx().create_err(FeatureGateError { span, explain: explain.into() });
-    add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
+    add_feature_diagnostics_for_issues(&mut err, sess, features, issues, false, None);
     err
 }
 
@@ -121,7 +121,7 @@ pub fn feature_err_issue(
 /// This diagnostic is only a warning and *does not cause compilation to fail*.
 #[track_caller]
 pub fn feature_warn(sess: &Session, feature: Symbol, span: Span, explain: &'static str) {
-    feature_warn_issue(sess, feature, span, GateIssue::Language, explain);
+    feature_warn_issues(sess, &[feature], span, GateIssues::Language, explain);
 }
 
 /// Construct a future incompatibility diagnostic for a feature gate.
@@ -133,15 +133,15 @@ pub fn feature_warn(sess: &Session, feature: Symbol, span: Span, explain: &'stat
 #[allow(rustc::diagnostic_outside_of_impl)]
 #[allow(rustc::untranslatable_diagnostic)]
 #[track_caller]
-pub fn feature_warn_issue(
+pub fn feature_warn_issues(
     sess: &Session,
-    feature: Symbol,
+    features: &[Symbol],
     span: Span,
-    issue: GateIssue,
+    issues: GateIssues,
     explain: &'static str,
 ) {
     let mut err = sess.dcx().struct_span_warn(span, explain);
-    add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
+    add_feature_diagnostics_for_issues(&mut err, sess, features, issues, false, None);
 
     // Decorate this as a future-incompatibility lint as in rustc_middle::lint::lint_level
     let lint = UNSTABLE_SYNTAX_PRE_EXPANSION;
@@ -161,7 +161,7 @@ pub fn add_feature_diagnostics<G: EmissionGuarantee>(
     sess: &Session,
     feature: Symbol,
 ) {
-    add_feature_diagnostics_for_issue(err, sess, feature, GateIssue::Language, false, None);
+    add_feature_diagnostics_for_issues(err, sess, &[feature], GateIssues::Language, false, None);
 }
 
 /// Adds the diagnostics for a feature to an existing error.
@@ -170,20 +170,21 @@ pub fn add_feature_diagnostics<G: EmissionGuarantee>(
 /// 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>(
+pub fn add_feature_diagnostics_for_issues<G: EmissionGuarantee>(
     err: &mut Diag<'_, G>,
     sess: &Session,
-    feature: Symbol,
-    issue: GateIssue,
+    features: &[Symbol],
+    issues: GateIssues,
     feature_from_cli: bool,
     inject_span: Option<Span>,
 ) {
-    if let Some(n) = find_feature_issue(feature, issue) {
+    for n in find_feature_issues(features, issues) {
         err.subdiagnostic(FeatureDiagnosticForIssue { n });
     }
 
     // #23973: do not suggest `#![feature(...)]` if we are in beta/stable
     if sess.psess.unstable_features.is_nightly_build() {
+        let feature: String = features.iter().map(|s| s.as_str()).intersperse(", ").collect();
         if feature_from_cli {
             err.subdiagnostic(CliFeatureDiagnosticHelp { feature });
         } else if let Some(span) = inject_span {