make some rustc_feature internals private, and ensure invariants with debug assertions

Author: RalfJung

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -604,7 +604,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
 if sess.opts.unstable_features.is_nightly_build(){
 return;
 }
-if features.enabled_features.is_empty(){
+if features.enabled_features().is_empty(){
 return;
 }
 letmut errored = false;
@@ -621,7 +621,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
 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
+.enabled_lang_features()
 .iter()
 .flat_map(|&(feature, _, since)| if feature == name { since }else{None})
 .next();
@@ -643,11 +643,11 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
 
 fncheck_incompatible_features(sess:&Session,features:&Features){
 let enabled_features = features
-.enabled_lang_features
+.enabled_lang_features()
 .iter()
 .copied()
 .map(|(name, span, _)| (name, span))
-.chain(features.enabled_lib_features.iter().copied());
+.chain(features.enabled_lib_features().iter().copied());
 
 for(f1, f2)in rustc_feature::INCOMPATIBLE_FEATURES
 .iter()
@@ -674,7 +674,7 @@ fn check_new_solver_banned_features(sess: &Session, features: &Features) {
 
 // Ban GCE with the new solver, because it does not implement GCE correctly.
 ifletSome(&(_, gce_span, _)) = features
-.enabled_lang_features
+.enabled_lang_features()
 .iter()
 .find(|&&(feat, _, _)| feat == sym::generic_const_exprs)
 {

compiler/rustc_expand/src/config.rs

@@ -88,7 +88,7 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
 // If the enabled feature is stable, record it.
 ifletSome(f) = ACCEPTED_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(name, mi.span(), since,None);
 continue;
 }
 
@@ -104,7 +104,6 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
 
 // If the enabled feature is unstable, record it.
 ifletSome(f) = UNSTABLE_FEATURES.iter().find(|f| name == f.feature.name){
-(f.set_enabled)(&mut features);
 // When the ICE comes from core, alloc or std (approximation of the standard
 // library), there's a chance that the person hitting the ICE may be using
 // -Zbuild-std or similar with an untested target. The bug is probably in the
@@ -115,7 +114,7 @@ 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(name, mi.span(),None,Some(f));
 continue;
 }
 

compiler/rustc_feature/src/unstable.rs

@@ -8,7 +8,7 @@ use super::{Feature, to_nonzero};
 
 pubstructUnstableFeature{
 pubfeature:Feature,
-pubset_enabled:fn(&mutFeatures),
+set_enabled:fn(&mutFeatures),
 }
 
 #[derive(PartialEq)]
@@ -54,11 +54,11 @@ macro_rules! declare_features {
  #[derive(Clone,Default,Debug)]
 pubstructFeatures{
 /// `#![feature]` attrs for language features, for error reporting.
-pubenabled_lang_features:Vec<(Symbol,Span,Option<Symbol>)>,
+ enabled_lang_features:Vec<(Symbol,Span,Option<Symbol>)>,
 /// `#![feature]` attrs for non-language (library) features.
-pubenabled_lib_features:Vec<(Symbol,Span)>,
+ enabled_lib_features:Vec<(Symbol,Span)>,
 /// `enabled_lang_features` + `enabled_lib_features`.
-pubenabled_features:FxHashSet<Symbol>,
+ enabled_features:FxHashSet<Symbol>,
 /// State of individual features (unstable lang features only).
 /// This is `true` if and only if the corresponding feature is listed in `enabled_lang_features`.
  $(
@@ -70,17 +70,27 @@ macro_rules! declare_features {
 implFeatures{
 pubfn set_enabled_lang_feature(
 &mutself,
-symbol:Symbol,
+name:Symbol,
  span:Span,
- since:Option<Symbol>
+ since:Option<Symbol>,
+ feature:Option<&UnstableFeature>,
 ){
-self.enabled_lang_features.push((symbol, span, since));
-self.enabled_features.insert(symbol);
+self.enabled_lang_features.push((name, span, since));
+self.enabled_features.insert(name);
+ifletSome(feature) = feature {
+ assert_eq!(feature.feature.name, name);
+(feature.set_enabled)(self);
+} else {
+// Ensure we don't skip a `set_enabled` call.
+ debug_assert!(UNSTABLE_FEATURES.iter().find(|f| name == f.feature.name).is_none());
+}
 }
 
-pubfn set_enabled_lib_feature(&mutself, symbol:Symbol, span:Span){
-self.enabled_lib_features.push((symbol, span));
-self.enabled_features.insert(symbol);
+pubfn set_enabled_lib_feature(&mutself, name:Symbol, span:Span){
+self.enabled_lib_features.push((name, span));
+self.enabled_features.insert(name);
+// Ensure we don't skip a `set_enabled` call.
+ debug_assert!(UNSTABLE_FEATURES.iter().find(|f| name == f.feature.name).is_none());
 }
 
 /// This is intended for hashing the set of enabled language features.
@@ -93,9 +103,36 @@ macro_rules! declare_features {
 [$(self.$feature asu8),+]
 }
 
+pubfn enabled_lang_features(&self) -> &Vec<(Symbol,Span,Option<Symbol>)> {
+&self.enabled_lang_features
+}
+
+pubfn enabled_lib_features(&self) -> &Vec<(Symbol,Span)> {
+&self.enabled_lib_features
+}
+
+pubfn enabled_features(&self) -> &FxHashSet<Symbol> {
+&self.enabled_features
+}
+
 /// Is the given feature enabled (via `#[feature(...)]`)?
 pubfn enabled(&self, feature:Symbol) -> bool{
-self.enabled_features.contains(&feature)
+let e = self.enabled_features.contains(&feature);
+if cfg!(debug_assertions){
+// Ensure this matches `self.$feature`, if that exists.
+let e2 = match feature {
+ $( sym::$feature => Some(self.$feature),)*
+ _ => None,
+};
+ifletSome(e2) = e2 {
+ assert_eq!(
+ e, e2,
+"mismatch in feature state for `{feature}`: \
+ `enabled_features` says {e} but `self.{feature}` says {e2}"
+);
+}
+}
+ e
 }
 
 /// Some features are known to be incomplete and using them is likely to have

compiler/rustc_lint/src/builtin.rs

@@ -2288,10 +2288,10 @@ impl EarlyLintPass for IncompleteInternalFeatures {
 fncheck_crate(&mutself,cx:&EarlyContext<'_>, _:&ast::Crate){
 let features = cx.builder.features();
  features
-.enabled_lang_features
+.enabled_lang_features()
 .iter()
 .map(|(name, span, _)| (name, span))
-.chain(features.enabled_lib_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)| {
 if features.incomplete(name){

compiler/rustc_passes/src/stability.rs

@@ -935,7 +935,7 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
  tcx.hir().visit_all_item_likes_in_crate(&mut missing);
 }
 
-let enabled_lang_features = &tcx.features().enabled_lang_features;
+let enabled_lang_features = tcx.features().enabled_lang_features();
 letmut lang_features = UnordSet::default();
 for&(feature, span, since)in enabled_lang_features {
 ifletSome(since) = since {
@@ -948,7 +948,7 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
 }
 }
 
-let enabled_lib_features = &tcx.features().enabled_lib_features;
+let enabled_lib_features = tcx.features().enabled_lib_features();
 letmut remaining_lib_features = FxIndexMap::default();
 for(feature, span)in enabled_lib_features {
 if remaining_lib_features.contains_key(&feature){

compiler/rustc_query_system/src/ich/impls_syntax.rs

@@ -112,8 +112,8 @@ impl<'tcx> HashStable<StableHashingContext<'tcx>> for rustc_feature::Features {
 fnhash_stable(&self,hcx:&mutStableHashingContext<'tcx>,hasher:&mutStableHasher){
 // Unfortunately we cannot exhaustively list fields here, since the
 // struct is macro generated.
-self.enabled_lang_features.hash_stable(hcx, hasher);
-self.enabled_lib_features.hash_stable(hcx, hasher);
+self.enabled_lang_features().hash_stable(hcx, hasher);
+self.enabled_lib_features().hash_stable(hcx, hasher);
 
 self.all_lang_features()[..].hash_stable(hcx, hasher);
 for feature in rustc_feature::UNSTABLE_FEATURES.iter(){