Use TrackedFeatures to track used features when calling enabled

Author: mu001999

compiler/rustc_feature/src/lib.rs

@@ -136,5 +136,6 @@ pub use builtin_attrs::{
 };
 pub use removed::REMOVED_LANG_FEATURES;
 pub use unstable::{
-    EnabledLangFeature, EnabledLibFeature, Features, INCOMPATIBLE_FEATURES, UNSTABLE_LANG_FEATURES,
+    EnabledLangFeature, EnabledLibFeature, Features, INCOMPATIBLE_FEATURES, TrackedFeatures,
+    UNSTABLE_LANG_FEATURES,
 };

compiler/rustc_feature/src/unstable.rs

@@ -1,6 +1,7 @@
 //! List of the unstable feature gates.
 
 use std::path::PathBuf;
+use std::sync::{LazyLock, Mutex};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use rustc_data_structures::fx::FxHashSet;
@@ -27,6 +28,9 @@ macro_rules! status_to_enum {
     };
 }
 
+static USED_FEATURES: LazyLock<Mutex<FxHashSet<Symbol>>> =
+    LazyLock::new(|| Mutex::new(FxHashSet::default()));
+
 /// A set of features to be used by later passes.
 ///
 /// There are two ways to check if a language feature `foo` is enabled:
@@ -35,6 +39,79 @@ macro_rules! status_to_enum {
 ///
 /// The former is preferred. `enabled` should only be used when the feature symbol is not a
 /// constant, e.g. a parameter, or when the feature is a library feature.
+///
+/// NOTE: Do NOT use any other method (e.g. `enabled_features`) to check if a feature is enabled.
+/// Only `enabled(&self, feature: Symbol)` and the generated `foo(&self)` methods will record
+/// feature usage. Using any other method will silently skip tracking and lead to incorrect
+/// "unused features" diagnostics.
+#[derive(Clone, Debug)]
+pub struct TrackedFeatures {
+    features: Features,
+}
+
+impl TrackedFeatures {
+    pub fn new(features: Features) -> Self {
+        Self { features }
+    }
+
+    pub fn unused_features(&self) -> Vec<(Symbol, Span)> {
+        let used_features = USED_FEATURES.lock().unwrap();
+        self.enabled_features_iter_stable_order()
+            .filter(|(f, _)| !used_features.contains(f))
+            .collect()
+    }
+
+    /// Is the given feature enabled (via `#[feature(...)]`)?
+    pub fn enabled(&self, feature: Symbol) -> bool {
+        USED_FEATURES.lock().unwrap().insert(feature);
+        self.features.enabled(feature)
+    }
+
+    /// Returns a list of [`EnabledLangFeature`] with info about:
+    ///
+    /// - Feature gate name.
+    /// - The span of the `#[feature]` attribute.
+    /// - For stable language features, version info for when it was stabilized.
+    pub fn enabled_lang_features(&self) -> &Vec<EnabledLangFeature> {
+        self.features.enabled_lang_features()
+    }
+
+    pub fn enabled_lib_features(&self) -> &Vec<EnabledLibFeature> {
+        self.features.enabled_lib_features()
+    }
+
+    pub fn enabled_features(&self) -> &FxHashSet<Symbol> {
+        &self.features.enabled_features()
+    }
+
+    /// Returns a iterator of enabled features in stable order.
+    pub fn enabled_features_iter_stable_order(
+        &self,
+    ) -> impl Iterator<Item = (Symbol, Span)> + Clone {
+        self.features.enabled_features_iter_stable_order()
+    }
+
+    pub fn dump_feature_usage_metrics(
+        &self,
+        metrics_path: PathBuf,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        self.features.dump_feature_usage_metrics(metrics_path)
+    }
+
+    /// Some features are known to be incomplete and using them is likely to have
+    /// unanticipated results, such as compiler crashes. We warn the user about these
+    /// to alert them.
+    pub fn incomplete(&self, feature: Symbol) -> bool {
+        self.features.incomplete(feature)
+    }
+
+    /// Some features are internal to the compiler and standard library and should not
+    /// be used in normal projects. We warn the user about these to alert them.
+    pub fn internal(&self, feature: Symbol) -> bool {
+        self.features.internal(feature)
+    }
+}
+
 #[derive(Clone, Default, Debug)]
 pub struct Features {
     /// `#![feature]` attrs for language features, for error reporting.
@@ -89,22 +166,18 @@ impl Features {
         &self.enabled_lib_features
     }
 
-    pub fn enabled_features(&self) -> &FxHashSet<Symbol> {
+    fn enabled_features(&self) -> &FxHashSet<Symbol> {
         &self.enabled_features
     }
 
-    /// Returns a iterator of enabled features in stable order.
-    pub fn enabled_features_iter_stable_order(
-        &self,
-    ) -> impl Iterator<Item = (Symbol, Span)> + Clone {
+    fn enabled_features_iter_stable_order(&self) -> impl Iterator<Item = (Symbol, Span)> + Clone {
         self.enabled_lang_features
             .iter()
             .map(|feat| (feat.gate_name, feat.attr_sp))
             .chain(self.enabled_lib_features.iter().map(|feat| (feat.gate_name, feat.attr_sp)))
     }
 
-    /// Is the given feature enabled (via `#[feature(...)]`)?
-    pub fn enabled(&self, feature: Symbol) -> bool {
+    fn enabled(&self, feature: Symbol) -> bool {
         self.enabled_features.contains(&feature)
     }
 }
@@ -123,17 +196,19 @@ macro_rules! declare_features {
             }),+
         ];
 
-        impl Features {
+        impl TrackedFeatures {
             $(
                 pub fn $feature(&self) -> bool {
-                    self.enabled_features.contains(&sym::$feature)
+                    self.enabled(sym::$feature)
                 }
             )*
+        }
 
+        impl Features {
             /// Some features are known to be incomplete and using them is likely to have
             /// unanticipated results, such as compiler crashes. We warn the user about these
             /// to alert them.
-            pub fn incomplete(&self, feature: Symbol) -> bool {
+            fn incomplete(&self, feature: Symbol) -> bool {
                 match feature {
                     $(
                         sym::$feature => status_to_enum!($status) == FeatureStatus::Incomplete,
@@ -711,7 +786,7 @@ declare_features! (
 );
 
 impl Features {
-    pub fn dump_feature_usage_metrics(
+    fn dump_feature_usage_metrics(
         &self,
         metrics_path: PathBuf,
     ) -> Result<(), Box<dyn std::error::Error>> {

compiler/rustc_interface/src/passes.rs

@@ -875,9 +875,15 @@ pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) {
     }
 }
 
+pub fn tracked_features_query<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx rustc_feature::TrackedFeatures {
+    let features = tcx.features_query(());
+    tcx.arena.alloc(rustc_feature::TrackedFeatures::new(features.clone()))
+}
+
 pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     let providers = &mut Providers::default();
     providers.queries.analysis = analysis;
+    providers.queries.tracked_features_query = |tcx, _| tracked_features_query(tcx);
     providers.queries.hir_crate = rustc_ast_lowering::lower_to_hir;
     providers.queries.resolver_for_lowering_raw = resolver_for_lowering_raw;
     providers.queries.stripped_cfg_items = |tcx, _| &tcx.resolutions(()).stripped_cfg_items[..];

compiler/rustc_middle/src/arena.rs

@@ -116,6 +116,7 @@ macro_rules! arena_types {
             [] stripped_cfg_items: rustc_hir::attrs::StrippedCfgItem,
             [] mod_child: rustc_middle::metadata::ModChild,
             [] features: rustc_feature::Features,
+            [] tracked_features: rustc_feature::TrackedFeatures,
             [decode] specialization_graph: rustc_middle::traits::specialization_graph::Graph,
             [] crate_inherent_impls: rustc_middle::ty::CrateInherentImpls,
             [] hir_owner_nodes: rustc_hir::OwnerNodes<'tcx>,

compiler/rustc_middle/src/queries.rs

@@ -2610,6 +2610,11 @@ rustc_queries! {
 
     query features_query(_: ()) -> &'tcx rustc_feature::Features {
         feedable
+        desc { "looking up raw feature gates" }
+    }
+
+    query tracked_features_query(_: ()) -> &'tcx rustc_feature::TrackedFeatures {
+        eval_always
         desc { "looking up enabled feature gates" }
     }
 

compiler/rustc_middle/src/ty/context.rs

@@ -38,7 +38,7 @@ use rustc_hir::definitions::{DefPathData, Definitions, DisambiguatorState};
 use rustc_hir::intravisit::VisitorExt;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::limit::Limit;
-use rustc_hir::{self as hir, HirId, Node, TraitCandidate, find_attr};
+use rustc_hir::{self as hir, CRATE_HIR_ID, HirId, Node, TraitCandidate, find_attr};
 use rustc_index::IndexVec;
 use rustc_query_system::cache::WithDepNode;
 use rustc_query_system::dep_graph::DepNodeIndex;
@@ -356,7 +356,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.recursion_limit().0
     }
 
-    type Features = &'tcx rustc_feature::Features;
+    type Features = &'tcx rustc_feature::TrackedFeatures;
 
     fn features(self) -> Self::Features {
         self.features()
@@ -893,7 +893,9 @@ impl<'tcx> rustc_type_ir::inherent::Safety<TyCtxt<'tcx>> for hir::Safety {
     }
 }
 
-impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>> for &'tcx rustc_feature::Features {
+impl<'tcx> rustc_type_ir::inherent::Features<TyCtxt<'tcx>>
+    for &'tcx rustc_feature::TrackedFeatures
+{
     fn generic_const_exprs(self) -> bool {
         self.generic_const_exprs()
     }
@@ -1934,8 +1936,8 @@ impl<'tcx> TyCtxt<'tcx> {
         )
     }
 
-    pub fn features(self) -> &'tcx rustc_feature::Features {
-        self.features_query(())
+    pub fn features(self) -> &'tcx rustc_feature::TrackedFeatures {
+        self.tracked_features_query(())
     }
 
     pub fn def_key(self, id: impl IntoQueryParam<DefId>) -> rustc_hir::definitions::DefKey {
@@ -2446,6 +2448,17 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     pub fn finish(self) {
+        for (feature, span) in self.features().unused_features() {
+            self.node_span_lint(
+                rustc_session::lint::builtin::UNUSED_FEATURES,
+                CRATE_HIR_ID,
+                span,
+                |lint| {
+                    lint.primary_message(format!("feature `{}` is declared but not used", feature));
+                },
+            );
+        }
+
         // We assume that no queries are run past here. If there are new queries
         // after this point, they'll show up as "<unknown>" in self-profiling data.
         self.alloc_self_profile_query_strings();

compiler/rustc_query_system/src/ich/impls_syntax.rs

@@ -100,6 +100,15 @@ impl<'tcx> HashStable<StableHashingContext<'tcx>> for rustc_feature::Features {
     }
 }
 
+impl<'tcx> HashStable<StableHashingContext<'tcx>> for rustc_feature::TrackedFeatures {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'tcx>, hasher: &mut StableHasher) {
+        // Unfortunately we cannot exhaustively list fields here, since the
+        // struct has private fields (to ensure its invariant is maintained)
+        self.enabled_lang_features().hash_stable(hcx, hasher);
+        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, stable_since } = self;