Add support for removed library features

Author: nilotpal-n7

Cargo.lock

@@ -2167,6 +2167,7 @@ version = "0.1.0"
 dependencies = [
  "html5ever",
  "regex",
+ "urlencoding",
 ]
 
 [[package]]
@@ -4411,7 +4412,6 @@ dependencies = [
  "rustc_middle",
  "rustc_query_system",
  "rustc_serialize",
- "rustc_session",
  "rustc_span",
  "tracing",
 ]
@@ -5834,6 +5834,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
 [[package]]
 name = "utf-8"
 version = "0.7.6"

compiler/rustc_attr_parsing/messages.ftl

@@ -247,3 +247,7 @@ attr_parsing_raw_dylib_only_windows =
 
 attr_parsing_whole_archive_needs_static =
     linking modifier `whole-archive` is only compatible with `static` linking kind
+
+attr_parsing_limit_invalid =
+    `limit` must be a non-negative integer
+    .label = {$error_str}

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -1,6 +1,40 @@
-use rustc_feature::AttributeType;
+use std::num::IntErrorKind;
+
+use rustc_hir::limit::Limit;
 
 use super::prelude::*;
+use crate::session_diagnostics::LimitInvalid;
+
+impl<S: Stage> AcceptContext<'_, '_, S> {
+    fn parse_limit_int(&self, nv: &NameValueParser) -> Option<Limit> {
+        let Some(limit) = nv.value_as_str() else {
+            self.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
+            return None;
+        };
+
+        let error_str = match limit.as_str().parse() {
+            Ok(i) => return Some(Limit::new(i)),
+            Err(e) => match e.kind() {
+                IntErrorKind::PosOverflow => "`limit` is too large",
+                IntErrorKind::Empty => "`limit` must be a non-negative integer",
+                IntErrorKind::InvalidDigit => "not a valid integer",
+                IntErrorKind::NegOverflow => {
+                    panic!(
+                        "`limit` should never negatively overflow since we're parsing into a usize and we'd get Empty instead"
+                    )
+                }
+                IntErrorKind::Zero => {
+                    panic!("zero is a valid `limit` so should have returned Ok() when parsing")
+                }
+                kind => panic!("unimplemented IntErrorKind variant: {:?}", kind),
+            },
+        };
+
+        self.emit_err(LimitInvalid { span: self.attr_span, value_span: nv.value_span, error_str });
+
+        None
+    }
+}
 
 pub(crate) struct CrateNameParser;
 
@@ -11,8 +45,8 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
     const TYPE: AttributeType = AttributeType::CrateLevel;
 
-    // FIXME: crate name is allowed on all targets and ignored,
-    //        even though it should only be valid on crates of course
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
@@ -34,3 +68,111 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
         })
     }
 }
+
+pub(crate) struct RecursionLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
+    const PATH: &[Symbol] = &[sym::recursion_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N", "https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::RecursionLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}
+
+pub(crate) struct MoveSizeLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
+    const PATH: &[Symbol] = &[sym::move_size_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::MoveSizeLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}
+
+pub(crate) struct TypeLengthLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
+    const PATH: &[Symbol] = &[sym::type_length_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::TypeLengthLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}
+
+pub(crate) struct PatternComplexityLimitParser;
+
+impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
+    const PATH: &[Symbol] = &[sym::pattern_complexity_limit];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const TEMPLATE: AttributeTemplate = template!(NameValueStr: "N");
+    const TYPE: AttributeType = AttributeType::CrateLevel;
+
+    // because it's a crate-level attribute, we already warn about it.
+    // Putting target limitations here would give duplicate warnings
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let ArgParser::NameValue(nv) = args else {
+            cx.expected_name_value(cx.attr_span, None);
+            return None;
+        };
+
+        Some(AttributeKind::PatternComplexityLimit {
+            limit: cx.parse_limit_int(nv)?,
+            attr_span: cx.attr_span,
+            limit_span: nv.value_span,
+        })
+    }
+}

compiler/rustc_attr_parsing/src/attributes/prelude.rs

@@ -1,8 +1,7 @@
-// templates
-#[doc(hidden)]
-pub(super) use rustc_feature::{AttributeTemplate, template};
 // data structures
 #[doc(hidden)]
+pub(super) use rustc_feature::{AttributeTemplate, AttributeType, template};
+#[doc(hidden)]
 pub(super) use rustc_hir::attrs::AttributeKind;
 #[doc(hidden)]
 pub(super) use rustc_hir::lints::AttributeLintKind;

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))
+    }
+}