Remove unused code in cfg_old

Author: JonathanBrouwer

compiler/rustc_attr_parsing/messages.ftl

@@ -6,9 +6,6 @@ attr_parsing_bundle_needs_static =
 
 attr_parsing_cfg_attr_bad_delim = wrong `cfg_attr` delimiters
 
-attr_parsing_cfg_predicate_identifier =
-    `cfg` predicate key must be an identifier
-
 attr_parsing_deprecated_item_suggestion =
     suggestions on deprecated items are unstable
     .help = add `#![feature(deprecated_suggestion)]` to the crate root
@@ -41,9 +38,6 @@ attr_parsing_empty_link_name =
     link name must not be empty
     .label = empty link name
 
-attr_parsing_expected_one_cfg_pattern =
-    expected 1 cfg-pattern
-
 attr_parsing_expected_single_version_literal =
     expected single version literal
 
@@ -241,10 +235,6 @@ attr_parsing_unstable_cfg_target_compact =
 attr_parsing_unstable_feature_bound_incompatible_stability = item annotated with `#[unstable_feature_bound]` should not be stable
     .help = If this item is meant to be stable, do not use any functions annotated with `#[unstable_feature_bound]`. Otherwise, mark this item as unstable with `#[unstable]`
 
-attr_parsing_unsupported_literal_cfg_boolean =
-    literal in `cfg` predicate value must be a boolean
-attr_parsing_unsupported_literal_cfg_string =
-    literal in `cfg` predicate value must be a string
 attr_parsing_unsupported_literal_generic =
     unsupported literal
 attr_parsing_unsupported_literal_suggestion =

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -4,7 +4,9 @@ use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
 use rustc_ast::{AttrItem, Attribute, CRATE_NODE_ID, LitKind, ast, token};
 use rustc_errors::{Applicability, PResult};
-use rustc_feature::{AttrSuggestionStyle, AttributeTemplate, Features, template};
+use rustc_feature::{
+    AttrSuggestionStyle, AttributeTemplate, Features, GatedCfg, find_gated_cfg, template,
+};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrPath, RustcVersion};
@@ -23,7 +25,7 @@ use crate::session_diagnostics::{
     AttributeParseError, AttributeParseErrorReason, CfgAttrBadDelim, MetaBadDelimSugg,
     ParsedDescription,
 };
-use crate::{AttributeParser, fluent_generated, parse_version, session_diagnostics, try_gate_cfg};
+use crate::{AttributeParser, fluent_generated, parse_version, session_diagnostics};
 
 pub const CFG_TEMPLATE: AttributeTemplate = template!(
     List: &["predicate"],
@@ -410,3 +412,19 @@ fn parse_cfg_attr_internal<'a>(
 
     Ok((cfg_predicate, expanded_attrs))
 }
+
+fn try_gate_cfg(name: Symbol, span: Span, sess: &Session, features: Option<&Features>) {
+    let gate = find_gated_cfg(|sym| sym == name);
+    if let (Some(feats), Some(gated_cfg)) = (features, gate) {
+        gate_cfg(gated_cfg, span, sess, feats);
+    }
+}
+
+#[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
+fn gate_cfg(gated_cfg: &GatedCfg, cfg_span: Span, sess: &Session, features: &Features) {
+    let (cfg, feature, has_feature) = gated_cfg;
+    if !has_feature(features) && !cfg_span.allows_unstable(*feature) {
+        let explain = format!("`cfg({cfg})` is experimental and subject to change");
+        feature_err(sess, *feature, cfg_span, explain).emit();
+    }
+}

compiler/rustc_attr_parsing/src/attributes/cfg_old.rs

@@ -32,7 +32,6 @@ mod prelude;
 pub(crate) mod allow_unstable;
 pub(crate) mod body;
 pub(crate) mod cfg;
-pub(crate) mod cfg_old;
 pub(crate) mod cfg_select;
 pub(crate) mod codegen_attrs;
 pub(crate) mod confusables;

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -8,7 +8,7 @@ use rustc_hir::{
 
 use super::prelude::*;
 use super::util::parse_version;
-use crate::session_diagnostics::{self, UnsupportedLiteralReason};
+use crate::session_diagnostics::{self};
 
 macro_rules! reject_outside_std {
     ($cx: ident) => {
@@ -304,7 +304,6 @@ pub(crate) fn parse_stability<S: Stage>(
         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),
             });
@@ -384,7 +383,6 @@ pub(crate) fn parse_unstability<S: Stage>(
         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()),
             });

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -107,7 +107,6 @@ pub mod validate_attr;
 pub use attributes::cfg::{
     CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg, parse_cfg_attr, parse_cfg_entry,
 };
-pub use attributes::cfg_old::*;
 pub use attributes::cfg_select::*;
 pub use attributes::util::{is_builtin_attr, parse_version};
 pub use context::{Early, Late, OmitDoc, ShouldEmit};

compiler/rustc_attr_parsing/src/lib.rs

@@ -12,19 +12,6 @@ use rustc_span::{Span, Symbol};
 
 use crate::fluent_generated as fluent;
 
-pub(crate) enum UnsupportedLiteralReason {
-    Generic,
-    CfgString,
-    CfgBoolean,
-}
-
-#[derive(Diagnostic)]
-#[diag(attr_parsing_expected_one_cfg_pattern, code = E0536)]
-pub(crate) struct ExpectedOneCfgPattern {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(attr_parsing_invalid_predicate, code = E0537)]
 pub(crate) struct InvalidPredicate {
@@ -234,28 +221,13 @@ pub(crate) struct InvalidReprHintNoValue {
 // FIXME(jdonszelmann): slowly phased out
 pub(crate) struct UnsupportedLiteral {
     pub span: Span,
-    pub reason: UnsupportedLiteralReason,
     pub is_bytestr: bool,
     pub start_point_span: Span,
 }
 
 impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UnsupportedLiteral {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
-        let mut diag = Diag::new(
-            dcx,
-            level,
-            match self.reason {
-                UnsupportedLiteralReason::Generic => {
-                    fluent::attr_parsing_unsupported_literal_generic
-                }
-                UnsupportedLiteralReason::CfgString => {
-                    fluent::attr_parsing_unsupported_literal_cfg_string
-                }
-                UnsupportedLiteralReason::CfgBoolean => {
-                    fluent::attr_parsing_unsupported_literal_cfg_boolean
-                }
-            },
-        );
+        let mut diag = Diag::new(dcx, level, fluent::attr_parsing_unsupported_literal_generic);
         diag.span(self.span);
         diag.code(E0565);
         if self.is_bytestr {
@@ -375,13 +347,6 @@ pub(crate) struct RustcAllowedUnstablePairing {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(attr_parsing_cfg_predicate_identifier)]
-pub(crate) struct CfgPredicateIdentifier {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(attr_parsing_deprecated_item_suggestion)]
 pub(crate) struct DeprecatedItemSuggestion {