Store feature stability un-split

Author: compiler-errors

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1178,18 +1178,14 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
 
     /// Iterates over all the stability attributes in the given crate.
     fn get_lib_features(self, _tcx: TyCtxt<'tcx>) -> LibFeatures {
-        let mut features = LibFeatures::default();
-        for (symbol, stability) in self.root.lib_features.decode(self) {
-            match stability {
-                FeatureStability::AcceptedSince(since) => {
-                    features.stable.insert(symbol, (since, DUMMY_SP));
-                }
-                FeatureStability::Unstable => {
-                    features.unstable.insert(symbol, DUMMY_SP);
-                }
-            }
+        LibFeatures {
+            stability: self
+                .root
+                .lib_features
+                .decode(self)
+                .map(|(sym, stab)| (sym, (stab, DUMMY_SP)))
+                .collect(),
         }
-        features
     }
 
     /// Iterates over the stability implications in the given crate (when a `#[unstable]` attribute

compiler/rustc_middle/src/middle/mod.rs

@@ -16,20 +16,14 @@ pub mod lib_features {
 
     #[derive(HashStable, Debug, Default)]
     pub struct LibFeatures {
-        /// A map from feature to stabilisation version.
-        pub stable: FxHashMap<Symbol, (Symbol, Span)>,
-        pub unstable: FxHashMap<Symbol, Span>,
+        pub stability: FxHashMap<Symbol, (FeatureStability, Span)>,
     }
 
     impl LibFeatures {
         pub fn to_vec(&self) -> Vec<(Symbol, FeatureStability)> {
-            let mut all_features: Vec<_> = self
-                .stable
-                .iter()
-                .map(|(f, (s, _))| (*f, FeatureStability::AcceptedSince(*s)))
-                .chain(self.unstable.iter().map(|(f, _)| (*f, FeatureStability::Unstable)))
-                .collect();
-            all_features.sort_unstable_by(|a, b| a.0.as_str().partial_cmp(b.0.as_str()).unwrap());
+            let mut all_features: Vec<_> =
+                self.stability.iter().map(|(&sym, &(stab, _))| (sym, stab)).collect();
+            all_features.sort_unstable_by(|(a, _), (b, _)| a.as_str().cmp(b.as_str()));
             all_features
         }
     }

compiler/rustc_passes/src/lib_features.rs

@@ -86,44 +86,38 @@ impl<'tcx> LibFeatureCollector<'tcx> {
     }
 
     fn collect_feature(&mut self, feature: Symbol, stability: FeatureStability, span: Span) {
-        let already_in_stable = self.lib_features.stable.contains_key(&feature);
-        let already_in_unstable = self.lib_features.unstable.contains_key(&feature);
+        let existing_stability = self.lib_features.stability.get(&feature).cloned();
 
-        match (stability, already_in_stable, already_in_unstable) {
-            (FeatureStability::AcceptedSince(since), _, false) => {
-                if let Some((prev_since, _)) = self.lib_features.stable.get(&feature)
-                    && *prev_since != since
-                {
-                    self.tcx.sess.emit_err(FeatureStableTwice {
-                        span,
-                        feature,
-                        since,
-                        prev_since: *prev_since,
-                    });
-                    return;
+        match (stability, existing_stability) {
+            (_, None) => {
+                self.lib_features.stability.insert(feature, (stability, span));
+            }
+            (
+                FeatureStability::AcceptedSince(since),
+                Some((FeatureStability::AcceptedSince(prev_since), _)),
+            ) => {
+                if prev_since != since {
+                    self.tcx.sess.emit_err(FeatureStableTwice { span, feature, since, prev_since });
                 }
-
-                self.lib_features.stable.insert(feature, (since, span));
             }
-            (FeatureStability::AcceptedSince(_), _, true) => {
+            (FeatureStability::AcceptedSince(_), Some((FeatureStability::Unstable, _))) => {
                 self.tcx.sess.emit_err(FeaturePreviouslyDeclared {
                     span,
                     feature,
                     declared: "stable",
                     prev_declared: "unstable",
                 });
             }
-            (FeatureStability::Unstable, false, _) => {
-                self.lib_features.unstable.insert(feature, span);
-            }
-            (FeatureStability::Unstable, true, _) => {
+            (FeatureStability::Unstable, Some((FeatureStability::AcceptedSince(_), _))) => {
                 self.tcx.sess.emit_err(FeaturePreviouslyDeclared {
                     span,
                     feature,
                     declared: "unstable",
                     prev_declared: "stable",
                 });
             }
+            (FeatureStability::Unstable, Some((FeatureStability::Unstable, _))) => { /* ok, duplicate `unstable` feature is ok. */
+            }
         }
     }
 }

compiler/rustc_passes/src/stability.rs

@@ -1051,12 +1051,11 @@ pub fn check_unused_or_stable_features(tcx: TyCtxt<'_>) {
 
     for (implied_by, feature) in remaining_implications {
         let local_defined_features = tcx.lib_features(rustc_hir::def_id::LOCAL_CRATE);
-        let span = *local_defined_features
-            .stable
+        let span = local_defined_features
+            .stability
             .get(&feature)
-            .map(|(_, span)| span)
-            .or_else(|| local_defined_features.unstable.get(&feature))
-            .expect("feature that implied another does not exist");
+            .expect("feature that implied another does not exist")
+            .1;
         tcx.sess.emit_err(errors::ImpliedFeatureNotExist { span, feature, implied_by });
     }