Add support for testing removed library features

- Introduced `unstable_removed` as an example of a removed library feature.

- Updated `rustc_session::Session` to track `removed_features`.

- Added new UI test `removed-library-feature.rs` under `tests/ui/stability-attribute/`.

- Test verifies that enabling `# produces E0557

  with removal version (`1.89.0`) and reason (`test_reason`).

Author: nilotpal-n7

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -2,8 +2,8 @@ use std::num::NonZero;
 
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::{
-    DefaultBodyStability, MethodKind, PartialConstStability, Stability, StabilityLevel,
-    StableSince, Target, UnstableReason, VERSION_PLACEHOLDER,
+    DefaultBodyStability, MethodKind, PartialConstStability, RemovedFeature, Stability,
+    StabilityLevel, StableSince, Target, UnstableReason, VERSION_PLACEHOLDER,
 };
 
 use super::prelude::*;
@@ -471,3 +471,149 @@ pub(crate) fn parse_unstability<S: Stage>(
         (Err(ErrorGuaranteed { .. }), _) | (_, Err(ErrorGuaranteed { .. })) => None,
     }
 }
+
+#[allow(dead_code)]
+#[derive(Default)]
+pub(crate) struct RemovedFeatureParser {
+    removed: Option<(RemovedFeature, Span)>,
+}
+
+impl<S: Stage> AttributeParser<S> for RemovedFeatureParser {
+    const ATTRIBUTES: AcceptMapping<Self, S> = &[(
+        &[sym::unstable_removed],
+        template!(List: &[r#"feature = "name", since = "1.2.3", reason = "...", issue = "N|none""#]),
+        |this, cx, args| {
+            // same staged-api restriction as other stability attrs
+            reject_outside_std!(cx);
+
+            let ArgParser::List(list) = args else {
+                cx.expected_list(cx.attr_span);
+                return;
+            };
+
+            let mut feature_opt: Option<Symbol> = None;
+            let mut reason_opt: Option<Symbol> = None;
+            let mut since_opt: Option<StableSince> = None;
+
+            for param in list.mixed() {
+                let param_span = param.span();
+                let Some(param) = param.meta_item() else {
+                    cx.emit_err(session_diagnostics::UnsupportedLiteral {
+                        span: param_span,
+                        reason: UnsupportedLiteralReason::Generic,
+                        is_bytestr: false,
+                        start_point_span: cx.sess().source_map().start_point(param_span),
+                    });
+                    return;
+                };
+
+                let word = param.path().word();
+                match word.map(|i| i.name) {
+                    Some(sym::feature) => {
+                        if insert_value_into_option_or_error(
+                            cx,
+                            &param,
+                            &mut feature_opt,
+                            word.unwrap(),
+                        )
+                        .is_none()
+                        {
+                            return;
+                        }
+                    }
+                    Some(sym::reason) => {
+                        if insert_value_into_option_or_error(
+                            cx,
+                            &param,
+                            &mut reason_opt,
+                            word.unwrap(),
+                        )
+                        .is_none()
+                        {
+                            return;
+                        }
+                    }
+                    Some(sym::since) => {
+                        if insert_value_into_option_or_error(
+                            cx,
+                            &param,
+                            &mut None::<Symbol>,
+                            word.unwrap(),
+                        )
+                        .is_none()
+                        {
+                            return;
+                        }
+                        // parse version string
+                        if let Some(s) = param.args().name_value().and_then(|nv| nv.value_as_str())
+                        {
+                            if s.as_str() == VERSION_PLACEHOLDER {
+                                since_opt = Some(StableSince::Current);
+                            } else if let Some(v) = super::util::parse_version(s) {
+                                since_opt = Some(StableSince::Version(v));
+                            } else {
+                                let err = cx.emit_err(session_diagnostics::InvalidSince {
+                                    span: cx.attr_span,
+                                });
+                                since_opt = Some(StableSince::Err(err));
+                            }
+                        } else {
+                            cx.expected_name_value(param.span(), Some(word.unwrap().name));
+                            return;
+                        }
+                    }
+                    _ => {
+                        cx.emit_err(session_diagnostics::UnknownMetaItem {
+                            span: param_span,
+                            item: param.path().to_string(),
+                            expected: &["feature", "reason", "since"],
+                        });
+                        return;
+                    }
+                }
+            }
+
+            // Validate presence and form of fields:
+            let feature = match feature_opt {
+                Some(f) if rustc_lexer::is_ident(f.as_str()) => f,
+                Some(_) => {
+                    cx.emit_err(session_diagnostics::NonIdentFeature { span: cx.attr_span });
+                    return;
+                }
+                None => {
+                    cx.emit_err(session_diagnostics::MissingFeature { span: cx.attr_span });
+                    return;
+                }
+            };
+
+            let since = match since_opt {
+                Some(s) => s,
+                None => {
+                    cx.emit_err(session_diagnostics::MissingSince { span: cx.attr_span });
+                    return;
+                }
+            };
+
+            let since_symbol = match since {
+                StableSince::Version(v) => Symbol::intern(&v.to_string()), // dynamic string — ok
+                StableSince::Current => sym::current,
+                StableSince::Err(_) => sym::err,
+            };
+
+            let removed = RemovedFeature {
+                feature,
+                reason: reason_opt.unwrap_or_else(|| sym::no_reason_given),
+                since: since_symbol,
+                span: cx.attr_span,
+            };
+
+            this.removed = Some((removed, cx.attr_span));
+        },
+    )];
+
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+
+    fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
+        self.removed.map(|(removed_feature, _span)| AttributeKind::RemovedFeature(removed_feature))
+    }
+}

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -468,6 +468,14 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
             Some(hir::ConstStability { level: hir::StabilityLevel::Stable { .. }, .. }) => {
                 // All good.
             }
+            Some(hir::ConstStability { level: hir::StabilityLevel::Removed { .. }, .. }) => {
+                // Treat removed like unstable, or hard-error.
+                // self.dcx().emit_err(errors::RemovedConstFeature {
+                //     span: self.span,
+                //     def_path: self.tcx.def_path_str(def_id),
+                // });
+                return;
+            }
             None => {
                 // This doesn't need a separate const-stability check -- const-stability equals
                 // regular stability, and regular stability is checked separately.
@@ -879,6 +887,17 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                         || (!intrinsic.must_be_overridden
                             && is_fn_or_trait_safe_to_expose_on_stable(tcx, callee));
                     match tcx.lookup_const_stability(callee) {
+                        Some(hir::ConstStability {
+                            level: hir::StabilityLevel::Removed { .. },
+                            ..
+                        }) => {
+                            // Treat removed like unstable, or hard-error.
+                            // self.dcx().emit_err(errors::RemovedConstFeature {
+                            //     span: self.span,
+                            //     def_path: self.tcx.def_path_str(def_id),
+                            // });
+                            return;
+                        }
                         None => {
                             // This doesn't need a separate const-stability check -- const-stability equals
                             // regular stability, and regular stability is checked separately.

compiler/rustc_feature/src/removed.rs

@@ -305,6 +305,7 @@ declare_features! (
     // `symbol.rs` when that happens.
     (removed, concat_idents, "1.90.0", Some(29599),
      Some("use the `${concat(..)}` metavariable expression instead"), 142704),
+    (removed, unstable_removed, "1.89.0", None, Some("test_reason")),
     // -------------------------------------------------------------------------
     // feature-group-end: removed library features
     // -------------------------------------------------------------------------

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -15,6 +15,7 @@ use thin_vec::ThinVec;
 
 use crate::attrs::pretty_printing::PrintAttribute;
 use crate::limit::Limit;
+use crate::stability::RemovedFeature;
 use crate::{DefaultBodyStability, PartialConstStability, RustcVersion, Stability};
 
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic, PrintAttribute)]
@@ -621,6 +622,9 @@ pub enum AttributeKind {
     /// Represents [`#[recursion_limit]`](https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute)
     RecursionLimit { attr_span: Span, limit_span: Span, limit: Limit },
 
+    /// Represents `#[]`
+    RemovedFeature(RemovedFeature),
+
     /// Represents [`#[repr]`](https://doc.rust-lang.org/stable/reference/type-layout.html#representations).
     Repr { reprs: ThinVec<(ReprAttr, Span)>, first_span: Span },
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -78,6 +78,7 @@ impl AttributeKind {
             ProcMacroDerive { .. } => No,
             PubTransparent(..) => Yes,
             RecursionLimit { .. } => No,
+            RemovedFeature(..) => No,
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcLayoutScalarValidRangeEnd(..) => Yes,

compiler/rustc_hir/src/stability.rs

@@ -1,7 +1,7 @@
 use std::num::NonZero;
 
 use rustc_macros::{Decodable, Encodable, HashStable_Generic, PrintAttribute};
-use rustc_span::{ErrorGuaranteed, Symbol, sym};
+use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 
 use crate::RustcVersion;
 use crate::attrs::PrintAttribute;
@@ -143,6 +143,10 @@ pub enum StabilityLevel {
         /// the `Symbol` is the deprecation message printed in that case.
         allowed_through_unstable_modules: Option<Symbol>,
     },
+    Removed {
+        since: Symbol,
+        reason: Symbol,
+    },
 }
 
 /// Rust release in which a feature is stabilized.
@@ -168,6 +172,7 @@ impl StabilityLevel {
         match *self {
             StabilityLevel::Stable { since, .. } => Some(since),
             StabilityLevel::Unstable { .. } => None,
+            StabilityLevel::Removed { .. } => None,
         }
     }
 }
@@ -205,3 +210,13 @@ impl UnstableReason {
         }
     }
 }
+
+/// Represents the `#![unstable_removed]` crate-level attribute.
+#[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(HashStable_Generic, PrintAttribute)]
+pub struct RemovedFeature {
+    pub span: Span,
+    pub feature: Symbol,
+    pub since: Symbol,
+    pub reason: Symbol,
+}

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -12,6 +12,7 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::owned_slice::OwnedSlice;
 use rustc_data_structures::sync::Lock;
 use rustc_data_structures::unhash::UnhashMap;
+use rustc_data_structures::unord::UnordMap;
 use rustc_expand::base::{SyntaxExtension, SyntaxExtensionKind};
 use rustc_expand::proc_macro::{AttrProcMacro, BangProcMacro, DeriveProcMacro};
 use rustc_hir::Safety;
@@ -1214,6 +1215,9 @@ impl<'a> CrateMetadataRef<'a> {
     /// Iterates over all the stability attributes in the given crate.
     fn get_lib_features(self) -> LibFeatures {
         LibFeatures {
+            stable: UnordMap::default(),
+            unstable: UnordMap::default(),
+            removed: UnordMap::default(),
             stability: self
                 .root
                 .lib_features

compiler/rustc_middle/src/middle/lib_features.rs

@@ -0,0 +1,59 @@
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_data_structures::unord::UnordMap;
+use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+use rustc_query_system::ich::StableHashingContext;
+use rustc_span::{Span, Symbol};
+
+#[derive(Clone, Debug, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
+pub struct RemovedLibFeatureInfo {
+    /// Reason (short free-form text).
+    pub reason: Symbol,
+    /// `since = "..."` version string.
+    pub since: Symbol,
+    /// Span where the `#[unstable_removed]` attribute was declared (crate root).
+    pub span: Span,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(HashStable, TyEncodable, TyDecodable)]
+pub enum FeatureStability {
+    AcceptedSince(Symbol),
+    Unstable { old_name: Option<Symbol> },
+    Removed { since: Symbol, reason: Symbol },
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct LibFeatures {
+    /// `#[stable(feature = "...", since = "...")]`
+    pub stable: UnordMap<Symbol, Span>,
+    /// `#[unstable(feature = "...", issue = "...")]`
+    pub unstable: UnordMap<Symbol, Span>,
+    /// `#![unstable_removed(...)]`
+    pub removed: UnordMap<Symbol, RemovedLibFeatureInfo>,
+    /// Internal stability tracking
+    pub stability: UnordMap<Symbol, (FeatureStability, Span)>,
+}
+
+impl LibFeatures {
+    pub fn to_sorted_vec(&self) -> Vec<(Symbol, FeatureStability)> {
+        self.stability
+            .to_sorted_stable_ord()
+            .iter()
+            .map(|&(&sym, &(stab, _))| (sym, stab))
+            .collect()
+    }
+
+    pub fn get_removed(&self, name: &Symbol) -> Option<&RemovedLibFeatureInfo> {
+        self.removed.get(name)
+    }
+}
+
+impl HashStable<StableHashingContext<'_>> for LibFeatures {
+    fn hash_stable(&self, hcx: &mut StableHashingContext<'_>, hasher: &mut StableHasher) {
+        // Hash each UnordMap deterministically
+        self.stable.to_sorted_stable_ord().hash_stable(hcx, hasher);
+        self.unstable.to_sorted_stable_ord().hash_stable(hcx, hasher);
+        self.removed.to_sorted_stable_ord().hash_stable(hcx, hasher);
+        self.stability.to_sorted_stable_ord().hash_stable(hcx, hasher);
+    }
+}

compiler/rustc_middle/src/middle/mod.rs

@@ -3,33 +3,7 @@ pub mod debugger_visualizer;
 pub mod dependency_format;
 pub mod exported_symbols;
 pub mod lang_items;
-pub mod lib_features {
-    use rustc_data_structures::unord::UnordMap;
-    use rustc_macros::{HashStable, TyDecodable, TyEncodable};
-    use rustc_span::{Span, Symbol};
-
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[derive(HashStable, TyEncodable, TyDecodable)]
-    pub enum FeatureStability {
-        AcceptedSince(Symbol),
-        Unstable { old_name: Option<Symbol> },
-    }
-
-    #[derive(HashStable, Debug, Default)]
-    pub struct LibFeatures {
-        pub stability: UnordMap<Symbol, (FeatureStability, Span)>,
-    }
-
-    impl LibFeatures {
-        pub fn to_sorted_vec(&self) -> Vec<(Symbol, FeatureStability)> {
-            self.stability
-                .to_sorted_stable_ord()
-                .iter()
-                .map(|&(&sym, &(stab, _))| (sym, stab))
-                .collect()
-        }
-    }
-}
+pub mod lib_features;
 pub mod privacy;
 pub mod region;
 pub mod resolve_bound_vars;