Merge pull request #22111 from ChayimFriedman2/unstable-features

internal: Create a struct of bools for unstable features, like we did for lang items

Author: ShoyuVanilla

crates/hir-def/src/lang_item.rs

@@ -40,7 +40,7 @@ pub fn crate_lang_items(db: &dyn DefDatabase, krate: Crate) -> Option<Box<LangIt
 
     let crate_def_map = crate_def_map(db, krate);
 
-    if !crate_def_map.is_unstable_feature_enabled(&sym::lang_items) {
+    if !crate_def_map.features().lang_items {
         return None;
     }
 

crates/hir-def/src/lib.rs

@@ -32,6 +32,7 @@ pub mod item_tree;
 
 pub mod builtin_derive;
 pub mod lang_item;
+pub mod unstable_features;
 
 pub mod hir;
 pub use self::hir::type_ref;

crates/hir-def/src/nameres.rs

@@ -68,7 +68,7 @@ use hir_expand::{
 };
 use intern::Symbol;
 use itertools::Itertools;
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
 use span::{Edition, FileAstId, FileId, ROOT_ERASED_FILE_AST_ID};
 use stdx::format_to;
 use syntax::{AstNode, SmolStr, SyntaxNode, ToSmolStr, ast};
@@ -83,6 +83,7 @@ use crate::{
     item_tree::TreeId,
     nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode},
     per_ns::PerNs,
+    unstable_features::UnstableFeatures,
     visibility::{Visibility, VisibilityExplicitness},
 };
 
@@ -216,7 +217,7 @@ struct DefMapCrateData {
     /// Custom tool modules registered with `#![register_tool]`.
     registered_tools: Vec<Symbol>,
     /// Unstable features of Rust enabled with `#![feature(A, B)]`.
-    unstable_features: FxHashSet<Symbol>,
+    unstable_features: UnstableFeatures,
     /// `#[rustc_coherence_is_core]`
     rustc_coherence_is_core: bool,
     no_core: bool,
@@ -233,7 +234,7 @@ impl DefMapCrateData {
             fn_proc_macro_mapping: FxHashMap::default(),
             fn_proc_macro_mapping_back: FxHashMap::default(),
             registered_tools: PREDEFINED_TOOLS.iter().map(|it| Symbol::intern(it)).collect(),
-            unstable_features: FxHashSet::default(),
+            unstable_features: UnstableFeatures::default(),
             rustc_coherence_is_core: false,
             no_core: false,
             no_std: false,
@@ -554,8 +555,9 @@ impl DefMap {
         &self.data.registered_tools
     }
 
-    pub fn is_unstable_feature_enabled(&self, feature: &Symbol) -> bool {
-        self.data.unstable_features.contains(feature)
+    #[inline]
+    pub fn features(&self) -> &UnstableFeatures {
+        &self.data.unstable_features
     }
 
     pub fn is_rustc_coherence_is_core(&self) -> bool {

crates/hir-def/src/nameres/collector.rs

@@ -316,7 +316,7 @@ impl<'db> DefCollector<'db> {
                                 _ => None,
                             },
                         );
-                    crate_data.unstable_features.extend(features);
+                    features.for_each(|feature| crate_data.unstable_features.enable(feature));
                 }
                 () if *attr_name == sym::register_tool => {
                     if let Some(ident) = attr.single_ident_value() {
@@ -2840,6 +2840,6 @@ foo!(KABOOM);
         assert_eq!(def_map.recursion_limit(), 4);
         assert!(def_map.is_no_core());
         assert!(def_map.is_no_std());
-        assert!(def_map.is_unstable_feature_enabled(&sym::register_tool));
+        assert!(def_map.features().is_enabled(&sym::register_tool));
     }
 }

crates/hir-def/src/unstable_features.rs

@@ -0,0 +1,91 @@
+//! Handling of unstable features.
+//!
+//! We define two kinds of handling: we have a map of all unstable features for a crate
+//! as `Symbol`s. This is mostly for external consumers.
+//!
+//! For analysis, we store them as a struct of bools, for fast access.
+
+use std::fmt;
+
+use base_db::Crate;
+use intern::{Symbol, sym};
+use rustc_hash::FxHashSet;
+
+use crate::db::DefDatabase;
+
+impl fmt::Debug for UnstableFeatures {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_set().entries(&self.all).finish()
+    }
+}
+
+impl PartialEq for UnstableFeatures {
+    fn eq(&self, other: &Self) -> bool {
+        self.all == other.all
+    }
+}
+
+impl Eq for UnstableFeatures {}
+
+impl UnstableFeatures {
+    #[inline]
+    pub fn is_enabled(&self, feature: &Symbol) -> bool {
+        self.all.contains(feature)
+    }
+
+    #[inline]
+    pub fn iter(&self) -> impl Iterator<Item = Symbol> {
+        self.all.iter().cloned()
+    }
+
+    pub(crate) fn shrink_to_fit(&mut self) {
+        self.all.shrink_to_fit();
+    }
+}
+
+#[salsa::tracked]
+impl UnstableFeatures {
+    /// Query unstable features for a crate.
+    ///
+    /// This is also available as `DefMap::features()`. Use that if you have a DefMap available.
+    /// Otherwise, use this, to not draw a dependency to the def map.
+    #[salsa::tracked(returns(ref))]
+    pub fn query(db: &dyn DefDatabase, krate: Crate) -> UnstableFeatures {
+        crate::crate_def_map(db, krate).features().clone()
+    }
+}
+
+macro_rules! define_unstable_features {
+    ( $( $feature:ident, )* ) => {
+        #[derive(Clone, Default)]
+        pub struct UnstableFeatures {
+            all: FxHashSet<Symbol>,
+
+            $( pub $feature: bool, )*
+        }
+
+        impl UnstableFeatures {
+            pub(crate) fn enable(&mut self, feature: Symbol) {
+                match () {
+                    $( () if feature == sym::$feature => self.$feature = true, )*
+                    _ => {}
+                }
+
+                self.all.insert(feature);
+            }
+        }
+    };
+}
+
+define_unstable_features! {
+    lang_items,
+    exhaustive_patterns,
+    generic_associated_type_extended,
+    arbitrary_self_types,
+    arbitrary_self_types_pointers,
+    supertrait_item_shadowing,
+    new_range,
+    never_type_fallback,
+    specialization,
+    min_specialization,
+}

crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs

@@ -4,9 +4,8 @@ use std::{cell::LazyCell, fmt};
 
 use hir_def::{
     EnumId, EnumVariantId, HasModule, LocalFieldId, ModuleId, VariantId, attrs::AttrFlags,
-    signatures::VariantFields,
+    signatures::VariantFields, unstable_features::UnstableFeatures,
 };
-use intern::sym;
 use rustc_pattern_analysis::{
     IndexVec, PatCx, PrivateUninhabitedField,
     constructor::{Constructor, ConstructorSet, VariantVisibility},
@@ -82,8 +81,7 @@ pub(crate) struct MatchCheckCtx<'a, 'db> {
 impl<'a, 'db> MatchCheckCtx<'a, 'db> {
     pub(crate) fn new(module: ModuleId, infcx: &'a InferCtxt<'db>, env: ParamEnv<'db>) -> Self {
         let db = infcx.interner.db;
-        let def_map = module.crate_def_map(db);
-        let exhaustive_patterns = def_map.is_unstable_feature_enabled(&sym::exhaustive_patterns);
+        let exhaustive_patterns = UnstableFeatures::query(db, module.krate(db)).exhaustive_patterns;
         Self { module, db, exhaustive_patterns, env, infcx }
     }
 

crates/hir-ty/src/dyn_compatibility.rs

@@ -6,8 +6,8 @@ use hir_def::{
     AssocItemId, ConstId, FunctionId, GenericDefId, HasModule, TraitId, TypeAliasId,
     TypeOrConstParamId, TypeParamId,
     hir::generics::{GenericParams, LocalTypeOrConstParamId},
-    nameres::crate_def_map,
     signatures::{FunctionSignature, TraitFlags, TraitSignature},
+    unstable_features::UnstableFeatures,
 };
 use rustc_hash::FxHashSet;
 use rustc_type_ir::{
@@ -111,8 +111,9 @@ where
     // rustc checks for non-lifetime binders here, but we don't support HRTB yet
 
     let trait_data = trait_.trait_items(db);
+    let mut features = None;
     for (_, assoc_item) in &trait_data.items {
-        dyn_compatibility_violation_for_assoc_item(db, trait_, *assoc_item, cb)?;
+        dyn_compatibility_violation_for_assoc_item(db, &mut features, trait_, *assoc_item, cb)?;
     }
 
     ControlFlow::Continue(())
@@ -274,8 +275,9 @@ fn contains_illegal_self_type_reference<'db, T: rustc_type_ir::TypeVisitable<DbI
     t.visit_with(&mut visitor).is_break()
 }
 
-fn dyn_compatibility_violation_for_assoc_item<F>(
-    db: &dyn HirDatabase,
+fn dyn_compatibility_violation_for_assoc_item<'db, F>(
+    db: &'db dyn HirDatabase,
+    features: &mut Option<&'db UnstableFeatures>,
     trait_: TraitId,
     item: AssocItemId,
     cb: &mut F,
@@ -297,8 +299,10 @@ where
             })
         }
         AssocItemId::TypeAliasId(it) => {
-            let def_map = crate_def_map(db, trait_.krate(db));
-            if def_map.is_unstable_feature_enabled(&intern::sym::generic_associated_type_extended) {
+            if features
+                .get_or_insert_with(|| UnstableFeatures::query(db, trait_.krate(db)))
+                .generic_associated_type_extended
+            {
                 ControlFlow::Continue(())
             } else {
                 let generic_params = GenericParams::of(db, item.into());

crates/hir-ty/src/infer.rs

@@ -44,6 +44,7 @@ use hir_def::{
     resolver::{HasResolver, ResolveValueResult, Resolver, TypeNs, ValueNs},
     signatures::{ConstSignature, EnumSignature, FunctionSignature, StaticSignature},
     type_ref::{ConstRef, LifetimeRefId, TypeRef, TypeRefId},
+    unstable_features::UnstableFeatures,
 };
 use hir_expand::{mod_path::ModPath, name::Name};
 use indexmap::IndexSet;
@@ -78,7 +79,7 @@ use crate::{
     lower::{
         ImplTraitIdx, ImplTraitLoweringMode, LifetimeElisionKind, diagnostics::TyLoweringDiagnostic,
     },
-    method_resolution::{CandidateId, MethodResolutionUnstableFeatures},
+    method_resolution::CandidateId,
     next_solver::{
         AliasTy, Const, DbInterner, ErrorGuaranteed, GenericArg, GenericArgs, Region,
         StoredGenericArgs, StoredTy, StoredTys, Ty, TyKind, Tys,
@@ -1112,11 +1113,11 @@ pub(crate) struct InferenceContext<'body, 'db> {
     /// and resolve the path via its methods. This will ensure proper error reporting.
     pub(crate) resolver: Resolver<'db>,
     target_features: OnceCell<(TargetFeatures<'db>, TargetFeatureIsSafeInTarget)>,
-    pub(crate) unstable_features: MethodResolutionUnstableFeatures,
     pub(crate) edition: Edition,
     pub(crate) generic_def: GenericDefId,
     pub(crate) table: unify::InferenceTable<'db>,
     pub(crate) lang_items: &'db LangItems,
+    pub(crate) features: &'db UnstableFeatures,
     /// The traits in scope, disregarding block modules. This is used for caching purposes.
     traits_in_scope: FxHashSet<TraitId>,
     pub(crate) result: InferenceResult,
@@ -1218,10 +1219,8 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
             return_ty: types.types.error, // set in collect_* calls
             types,
             target_features: OnceCell::new(),
-            unstable_features: MethodResolutionUnstableFeatures::from_def_map(
-                resolver.top_level_def_map(),
-            ),
             lang_items: table.interner().lang_items(),
+            features: resolver.top_level_def_map().features(),
             edition: resolver.krate().data(db).edition,
             table,
             tuple_field_accesses_rev: Default::default(),
@@ -2317,7 +2316,7 @@ impl<'body, 'db> InferenceContext<'body, 'db> {
     }
 
     fn has_new_range_feature(&self) -> bool {
-        self.resolver.top_level_def_map().is_unstable_feature_enabled(&sym::new_range)
+        self.features.new_range
     }
 
     fn resolve_range(&self) -> Option<AdtId> {

crates/hir-ty/src/infer/fallback.rs

@@ -1,6 +1,5 @@
 //! Fallback of infer vars to `!` and `i32`/`f64`.
 
-use intern::sym;
 use petgraph::{
     Graph,
     visit::{Dfs, Walker},
@@ -80,7 +79,7 @@ impl<'db> InferenceContext<'_, 'db> {
             return DivergingFallbackBehavior::ToNever;
         }
 
-        if self.resolver.def_map().is_unstable_feature_enabled(&sym::never_type_fallback) {
+        if self.features.never_type_fallback {
             return DivergingFallbackBehavior::ContextDependent;
         }
 

crates/hir-ty/src/method_resolution.rs

@@ -23,8 +23,9 @@ use hir_def::{
     nameres::{DefMap, block_def_map, crate_def_map},
     resolver::Resolver,
     signatures::{ConstSignature, FunctionSignature},
+    unstable_features::UnstableFeatures,
 };
-use intern::{Symbol, sym};
+use intern::Symbol;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustc_type_ir::{
     TypeVisitableExt,
@@ -57,32 +58,13 @@ pub use self::probe::{
     Candidate, CandidateKind, CandidateStep, CandidateWithPrivate, Mode, Pick, PickKind,
 };
 
-#[derive(Debug, Clone)]
-pub struct MethodResolutionUnstableFeatures {
-    arbitrary_self_types: bool,
-    arbitrary_self_types_pointers: bool,
-    supertrait_item_shadowing: bool,
-}
-
-impl MethodResolutionUnstableFeatures {
-    pub fn from_def_map(def_map: &DefMap) -> Self {
-        Self {
-            arbitrary_self_types: def_map.is_unstable_feature_enabled(&sym::arbitrary_self_types),
-            arbitrary_self_types_pointers: def_map
-                .is_unstable_feature_enabled(&sym::arbitrary_self_types_pointers),
-            supertrait_item_shadowing: def_map
-                .is_unstable_feature_enabled(&sym::supertrait_item_shadowing),
-        }
-    }
-}
-
 pub struct MethodResolutionContext<'a, 'db> {
     pub infcx: &'a InferCtxt<'db>,
     pub resolver: &'a Resolver<'db>,
     pub param_env: ParamEnv<'db>,
     pub traits_in_scope: &'a FxHashSet<TraitId>,
     pub edition: Edition,
-    pub unstable_features: &'a MethodResolutionUnstableFeatures,
+    pub features: &'a UnstableFeatures,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, salsa::Update)]
@@ -201,7 +183,7 @@ impl<'a, 'db> InferenceContext<'a, 'db> {
             param_env: self.table.param_env,
             traits_in_scope,
             edition: self.edition,
-            unstable_features: &self.unstable_features,
+            features: self.features,
         };
         f(&ctx)
     }