Introduce EnabledLangFeature and LangFeatureStability

Instead of passing around random 3-tuples of `(gate_name, attr_sp,
since)`.

Author: jieyouxu

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,7 +1,10 @@
 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, GateIssue,
+    LangFeatureStability,
+};
 use rustc_session::Session;
 use rustc_session::parse::{feature_err, feature_err_issue, feature_warn};
 use rustc_span::source_map::Spanned;
@@ -620,11 +623,15 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
         let mut all_stable = true;
         for ident in attr.meta_item_list().into_iter().flatten().flat_map(|nested| nested.ident()) {
             let name = ident.name;
-            let stable_since = features
-                .enabled_lang_features()
-                .iter()
-                .flat_map(|&(feature, _, since)| if feature == name { since } else { None })
-                .next();
+            let stable_since = features.enabled_lang_features().iter().find_map(|feat| {
+                if feat.gate_name == name
+                    && let LangFeatureStability::StableSince { version } = feat.stability
+                {
+                    Some(version)
+                } else {
+                    None
+                }
+            });
             if let Some(since) = stable_since {
                 err.stable_features.push(errors::StableFeature { name, since });
             } else {
@@ -645,13 +652,12 @@ fn check_incompatible_features(sess: &Session, features: &Features) {
     let enabled_features = features
         .enabled_lang_features()
         .iter()
-        .copied()
-        .map(|(name, span, _)| (name, span))
+        .map(|feat| (feat.gate_name, feat.attr_sp))
         .chain(features.enabled_lib_features().iter().copied());
 
     for (f1, f2) in rustc_feature::INCOMPATIBLE_FEATURES
         .iter()
-        .filter(|&&(f1, f2)| features.enabled(f1) && features.enabled(f2))
+        .filter(|(f1, f2)| features.enabled(*f1) && features.enabled(*f2))
     {
         if let Some((f1_name, f1_span)) = enabled_features.clone().find(|(name, _)| name == f1) {
             if let Some((f2_name, f2_span)) = enabled_features.clone().find(|(name, _)| name == f2)
@@ -673,10 +679,11 @@ fn check_new_solver_banned_features(sess: &Session, features: &Features) {
     }
 
     // Ban GCE with the new solver, because it does not implement GCE correctly.
-    if let Some(&(_, gce_span, _)) = features
+    if let Some(gce_span) = features
         .enabled_lang_features()
         .iter()
-        .find(|&&(feat, _, _)| feat == sym::generic_const_exprs)
+        .find(|feat| feat.gate_name == sym::generic_const_exprs)
+        .map(|feat| feat.attr_sp)
     {
         sess.dcx().emit_err(errors::IncompatibleFeatures {
             spans: vec![gce_span],

compiler/rustc_expand/src/config.rs

@@ -11,8 +11,8 @@ use rustc_ast::{
 use rustc_attr as attr;
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_feature::{
-    ACCEPTED_LANG_FEATURES, AttributeSafety, Features, REMOVED_LANG_FEATURES,
-    UNSTABLE_LANG_FEATURES,
+    ACCEPTED_LANG_FEATURES, AttributeSafety, EnabledLangFeature, Features, LangFeatureStability,
+    REMOVED_LANG_FEATURES, UNSTABLE_LANG_FEATURES,
 };
 use rustc_lint_defs::BuiltinLintDiag;
 use rustc_parse::validate_attr;
@@ -88,8 +88,13 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
 
             // If the enabled feature is stable, record it.
             if let Some(f) = ACCEPTED_LANG_FEATURES.iter().find(|f| name == f.name) {
-                let since = Some(Symbol::intern(f.since));
-                features.set_enabled_lang_feature(name, mi.span(), since);
+                features.set_enabled_lang_feature(EnabledLangFeature {
+                    gate_name: name,
+                    attr_sp: mi.span(),
+                    stability: LangFeatureStability::StableSince {
+                        version: Symbol::intern(f.since),
+                    },
+                });
                 continue;
             }
 
@@ -115,7 +120,12 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
                 {
                     sess.using_internal_features.store(true, std::sync::atomic::Ordering::Relaxed);
                 }
-                features.set_enabled_lang_feature(name, mi.span(), None);
+
+                features.set_enabled_lang_feature(EnabledLangFeature {
+                    gate_name: name,
+                    attr_sp: mi.span(),
+                    stability: LangFeatureStability::Unstable,
+                });
                 continue;
             }
 

compiler/rustc_feature/src/lib.rs

@@ -135,4 +135,7 @@ pub use builtin_attrs::{
     is_valid_for_get_attr,
 };
 pub use removed::REMOVED_LANG_FEATURES;
-pub use unstable::{Features, INCOMPATIBLE_FEATURES, UNSTABLE_LANG_FEATURES};
+pub use unstable::{
+    EnabledLangFeature, Features, INCOMPATIBLE_FEATURES, LangFeatureStability,
+    UNSTABLE_LANG_FEATURES,
+};

compiler/rustc_feature/src/unstable.rs

@@ -36,31 +36,53 @@ macro_rules! status_to_enum {
 #[derive(Clone, Default, Debug)]
 pub struct Features {
     /// `#![feature]` attrs for language features, for error reporting.
-    enabled_lang_features: Vec<(Symbol, Span, Option<Symbol>)>,
+    enabled_lang_features: Vec<EnabledLangFeature>,
     /// `#![feature]` attrs for non-language (library) features.
     enabled_lib_features: Vec<(Symbol, Span)>,
     /// `enabled_lang_features` + `enabled_lib_features`.
     enabled_features: FxHashSet<Symbol>,
 }
 
+/// Information about an enabled language feature.
+#[derive(Debug, Copy, Clone)]
+pub struct EnabledLangFeature {
+    /// Name of the feature gate guarding the language feature.
+    pub gate_name: Symbol,
+    /// Span of the `#[feature(...)]` attribute.
+    pub attr_sp: Span,
+    /// Stability info of the language feature.
+    pub stability: LangFeatureStability,
+}
+
+/// Stability info for a given [`EnabledLangFeature`].
+#[derive(Debug, Copy, PartialEq, Clone)]
+pub enum LangFeatureStability {
+    /// The [`EnabledLangFeature`] is not yet stable.
+    Unstable,
+    /// Version when the [`EnabledLangFeature`] became stable.
+    StableSince { version: Symbol },
+}
+
 impl Features {
     /// `since` should be set for stable features that are nevertheless enabled with a `#[feature]`
     /// attribute, indicating since when they are stable.
-    pub fn set_enabled_lang_feature(&mut self, name: Symbol, span: Span, since: Option<Symbol>) {
-        self.enabled_lang_features.push((name, span, since));
-        self.enabled_features.insert(name);
+    pub fn set_enabled_lang_feature(&mut self, feat: EnabledLangFeature) {
+        self.enabled_lang_features.push(feat);
+        self.enabled_features.insert(feat.gate_name);
     }
 
     pub fn set_enabled_lib_feature(&mut self, name: Symbol, span: Span) {
         self.enabled_lib_features.push((name, span));
         self.enabled_features.insert(name);
     }
 
-    /// Returns a list of triples with:
-    /// - feature gate name
-    /// - the span of the `#[feature]` attribute
-    /// - (for already stable features) the version since which it is stable
-    pub fn enabled_lang_features(&self) -> &Vec<(Symbol, Span, Option<Symbol>)> {
+    /// Returns a list of [`EnabledLangFeature`] with info about:
+    ///
+    /// - Feature gate name.
+    /// - The span of the `#[feature]` attribute.
+    /// - Language feature stability. For stable language features, this will contain the version
+    ///   since which it is stable.
+    pub fn enabled_lang_features(&self) -> &Vec<EnabledLangFeature> {
         &self.enabled_lang_features
     }
 

compiler/rustc_lint/src/builtin.rs

@@ -2290,10 +2290,10 @@ impl EarlyLintPass for IncompleteInternalFeatures {
         features
             .enabled_lang_features()
             .iter()
-            .map(|(name, span, _)| (name, span))
-            .chain(features.enabled_lib_features().iter().map(|(name, span)| (name, span)))
-            .filter(|(&name, _)| features.incomplete(name) || features.internal(name))
-            .for_each(|(&name, &span)| {
+            .map(|feat| (feat.gate_name, feat.attr_sp))
+            .chain(features.enabled_lib_features().into_iter().copied())
+            .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)
                         .map(|n| BuiltinFeatureIssueNote { n });

compiler/rustc_passes/src/stability.rs

@@ -10,7 +10,7 @@ use rustc_attr::{
 };
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
-use rustc_feature::ACCEPTED_LANG_FEATURES;
+use rustc_feature::{ACCEPTED_LANG_FEATURES, EnabledLangFeature, LangFeatureStability};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId, LocalModDefId};
@@ -937,14 +937,14 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
 
     let enabled_lang_features = tcx.features().enabled_lang_features();
     let mut lang_features = UnordSet::default();
-    for &(feature, span, since) in enabled_lang_features {
-        if let Some(since) = since {
+    for EnabledLangFeature { gate_name, attr_sp, stability } in enabled_lang_features {
+        if let LangFeatureStability::StableSince { version } = stability {
             // Warn if the user has enabled an already-stable lang feature.
-            unnecessary_stable_feature_lint(tcx, span, feature, since);
+            unnecessary_stable_feature_lint(tcx, *attr_sp, *gate_name, *version);
         }
-        if !lang_features.insert(feature) {
+        if !lang_features.insert(gate_name) {
             // Warn if the user enables a lang feature multiple times.
-            tcx.dcx().emit_err(errors::DuplicateFeatureErr { span, feature });
+            tcx.dcx().emit_err(errors::DuplicateFeatureErr { span: *attr_sp, feature: *gate_name });
         }
     }
 

compiler/rustc_query_system/src/ich/impls_syntax.rs

@@ -116,3 +116,24 @@ impl<'tcx> HashStable<StableHashingContext<'tcx>> for rustc_feature::Features {
         self.enabled_lib_features().hash_stable(hcx, hasher);
     }
 }
+
+impl<'tcx> HashStable<StableHashingContext<'tcx>> for rustc_feature::EnabledLangFeature {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'tcx>, hasher: &mut StableHasher) {
+        let rustc_feature::EnabledLangFeature { gate_name, attr_sp, stability } = self;
+        gate_name.hash_stable(hcx, hasher);
+        attr_sp.hash_stable(hcx, hasher);
+        stability.hash_stable(hcx, hasher);
+    }
+}
+
+impl<'tcx> HashStable<StableHashingContext<'tcx>> for rustc_feature::LangFeatureStability {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'tcx>, hasher: &mut StableHasher) {
+        std::mem::discriminant(self).hash_stable(hcx, hasher);
+        match self {
+            rustc_feature::LangFeatureStability::Unstable => {}
+            rustc_feature::LangFeatureStability::StableSince { version } => {
+                version.hash_stable(hcx, hasher)
+            }
+        }
+    }
+}