Move parse_cfg_attr to rustc_attr_parsing

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>

Author: JonathanBrouwer

compiler/rustc_attr_parsing/messages.ftl

@@ -264,3 +264,13 @@ attr_parsing_unused_multiple =
 
 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}
+
+attr_parsing_cfg_attr_bad_delim = wrong `cfg_attr` delimiters
+
+attr_parsing_malformed_cfg_attr = malformed `cfg_attr` attribute input
+ .suggestion = missing condition and attribute
+ .note = for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -1,17 +1,23 @@
-use rustc_ast::{LitKind, NodeId};
+use rustc_ast::token::Delimiter;
+use rustc_ast::tokenstream::DelimSpan;
+use rustc_ast::{AttrItem, Attribute, LitKind, MetaItemInner, NodeId, ast, token};
+use rustc_errors::PResult;
 use rustc_feature::{AttributeTemplate, Features, template};
 use rustc_hir::RustcVersion;
 use rustc_hir::attrs::CfgEntry;
+use rustc_parse::parser::{ForceCollect, Parser};
+use rustc_parse::{exp, parse_in};
 use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::UNEXPECTED_CFGS;
-use rustc_session::parse::feature_err;
+use rustc_session::parse::{ParseSess, feature_err};
 use rustc_span::{Span, Symbol, sym};
 use thin_vec::ThinVec;
 
 use crate::context::{AcceptContext, ShouldEmit, Stage};
 use crate::parser::{ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser};
+use crate::session_diagnostics::{CfgAttrBadDelim, MalformedCfgAttr, MetaBadDelimSugg};
 use crate::{
  CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics, try_gate_cfg,
 };
@@ -301,3 +307,66 @@ impl EvalConfigResult {
  }
 }
 
+pub fn parse_cfg_attr(
+ cfg_attr: &Attribute,
+ psess: &ParseSess,
+) -> Option<(MetaItemInner, Vec<(AttrItem, Span)>)> {
+ const CFG_ATTR_GRAMMAR_HELP: &str = "#[cfg_attr(condition, attribute, other_attribute, ...)]";
+ const CFG_ATTR_NOTE_REF: &str = "for more information, visit \
+ <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>";
+
+ match cfg_attr.get_normal_item().args {
+ ast::AttrArgs::Delimited(ast::DelimArgs { dspan, delim, ref tokens })
+ if !tokens.is_empty() =>
+ {
+ check_cfg_attr_bad_delim(psess, dspan, delim);
+ match parse_in(psess, tokens.clone(), "`cfg_attr` input", |p| {
+ parse_cfg_attr_internal(p)
+ }) {
+ Ok(r) => return Some(r),
+ Err(e) => {
+ e.with_help(format!("the valid syntax is `{CFG_ATTR_GRAMMAR_HELP}`"))
+ .with_note(CFG_ATTR_NOTE_REF)
+ .emit();
+ }
+ }
+ }
+ _ => {
+ psess
+ .dcx()
+ .emit_err(MalformedCfgAttr { span: cfg_attr.span, sugg: CFG_ATTR_GRAMMAR_HELP });
+ }
+ }
+ None
+}
+
+fn check_cfg_attr_bad_delim(psess: &ParseSess, span: DelimSpan, delim: Delimiter) {
+ if let Delimiter::Parenthesis = delim {
+ return;
+ }
+ psess.dcx().emit_err(CfgAttrBadDelim {
+ span: span.entire(),
+ sugg: MetaBadDelimSugg { open: span.open, close: span.close },
+ });
+}
+
+/// Parses `cfg_attr(pred, attr_item_list)` where `attr_item_list` is comma-delimited.
+fn parse_cfg_attr_internal<'a>(
+ parser: &mut Parser<'a>,
+) -> PResult<'a, (ast::MetaItemInner, Vec<(ast::AttrItem, Span)>)> {
+ let cfg_predicate = parser.parse_meta_item_inner()?;
+ parser.expect(exp!(Comma))?;
+
+ // Presumably, the majority of the time there will only be one attr.
+ let mut expanded_attrs = Vec::with_capacity(1);
+ while parser.token != token::Eof {
+ let lo = parser.token.span;
+ let item = parser.parse_attr_item(ForceCollect::Yes)?;
+ expanded_attrs.push((item, lo.to(parser.prev_token.span)));
+ if !parser.eat(exp!(Comma)) {
+ break;
+ }
+ }
+
+ Ok((cfg_predicate, expanded_attrs))
+}

compiler/rustc_attr_parsing/src/lib.rs

@@ -105,7 +105,9 @@ mod session_diagnostics;
 mod target_checking;
 pub mod validate_attr;
 
-pub use attributes::cfg::{CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg};
+pub use attributes::cfg::{
+ CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg, parse_cfg_attr,
+};
 pub use attributes::cfg_old::*;
 pub use attributes::util::{is_builtin_attr, is_doc_alias_attrs_contain_symbol, parse_version};
 pub use context::{Early, Late, OmitDoc, ShouldEmit};

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -971,3 +971,22 @@ pub(crate) struct LimitInvalid<'a> {
  pub value_span: Span,
  pub error_str: &'a str,
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_cfg_attr_bad_delim)]
+pub(crate) struct CfgAttrBadDelim {
+ #[primary_span]
+ pub span: Span,
+ #[subdiagnostic]
+ pub sugg: MetaBadDelimSugg,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_malformed_cfg_attr)]
+#[note]
+pub(crate) struct MalformedCfgAttr {
+ #[primary_span]
+ #[suggestion(style = "verbose", code = "{sugg}")]
+ pub span: Span,
+ pub sugg: &'static str,
+}

compiler/rustc_expand/src/config.rs

@@ -303,7 +303,7 @@ impl<'a> StripUnconfigured<'a> {
  let trace_attr = attr_into_trace(cfg_attr.clone(), sym::cfg_attr_trace);
 
  let Some((cfg_predicate, expanded_attrs)) =
- rustc_parse::parse_cfg_attr(cfg_attr, &self.sess.psess)
+ rustc_attr_parsing::parse_cfg_attr(cfg_attr, &self.sess.psess)
  else {
  return vec![trace_attr];
  };

compiler/rustc_parse/messages.ftl

@@ -122,7 +122,6 @@ parse_cannot_be_raw_lifetime = `{$ident}` cannot be a raw lifetime
 parse_catch_after_try = keyword `catch` cannot follow a `try` block
  .help = try using `match` on the result of the `try` block instead
 
-parse_cfg_attr_bad_delim = wrong `cfg_attr` delimiters
 parse_colon_as_semi = statements are terminated with a semicolon
  .suggestion = use a semicolon instead
 
@@ -573,10 +572,6 @@ parse_macro_rules_missing_bang = expected `!` after `macro_rules`
 parse_macro_rules_visibility = can't qualify macro_rules invocation with `{$vis}`
  .suggestion = try exporting the macro
 
-parse_malformed_cfg_attr = malformed `cfg_attr` attribute input
- .suggestion = missing condition and attribute
- .note = for more information, visit <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>
-
 parse_malformed_loop_label = malformed loop label
  .suggestion = use the correct loop label format
 
@@ -610,8 +605,6 @@ parse_maybe_report_ambiguous_plus =
  ambiguous `+` in a type
  .suggestion = use parentheses to disambiguate
 
-parse_meta_bad_delim_suggestion = the delimiters should be `(` and `)`
-
 parse_mismatched_closing_delimiter = mismatched closing delimiter: `{$delimiter}`
  .label_unmatched = mismatched closing delimiter
  .label_opening_candidate = closing delimiter possibly meant for this

compiler/rustc_parse/src/errors.rs

@@ -3351,34 +3351,6 @@ pub(crate) struct KwBadCase<'a> {
  pub kw: &'a str,
 }
 
-#[derive(Diagnostic)]
-#[diag(parse_cfg_attr_bad_delim)]
-pub(crate) struct CfgAttrBadDelim {
- #[primary_span]
- pub span: Span,
- #[subdiagnostic]
- pub sugg: MetaBadDelimSugg,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(parse_meta_bad_delim_suggestion, applicability = "machine-applicable")]
-pub(crate) struct MetaBadDelimSugg {
- #[suggestion_part(code = "(")]
- pub open: Span,
- #[suggestion_part(code = ")")]
- pub close: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag(parse_malformed_cfg_attr)]
-#[note]
-pub(crate) struct MalformedCfgAttr {
- #[primary_span]
- #[suggestion(style = "verbose", code = "{sugg}")]
- pub span: Span,
- pub sugg: &'static str,
-}
-
 #[derive(Diagnostic)]
 #[diag(parse_unknown_builtin_construct)]
 pub(crate) struct UnknownBuiltinConstruct {

compiler/rustc_parse/src/lib.rs

@@ -18,8 +18,8 @@ use std::str::Utf8Error;
 use std::sync::Arc;
 
 use rustc_ast as ast;
-use rustc_ast::tokenstream::{DelimSpan, TokenStream};
-use rustc_ast::{AttrItem, Attribute, MetaItemInner, token};
+use rustc_ast::token;
+use rustc_ast::tokenstream::TokenStream;
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Diag, EmissionGuarantee, FatalError, PResult, pluralize};
 use rustc_session::parse::ParseSess;
@@ -32,7 +32,6 @@ pub const MACRO_ARGUMENTS: Option<&str> = Some("macro arguments");
 #[macro_use]
 pub mod parser;
 use parser::Parser;
-use rustc_ast::token::Delimiter;
 
 use crate::lexer::StripTokens;
 
@@ -230,45 +229,3 @@ pub fn fake_token_stream_for_crate(psess: &ParseSess, krate: &ast::Crate) -> Tok
  Some(krate.spans.inner_span),
  ))
 }
-
-pub fn parse_cfg_attr(
- cfg_attr: &Attribute,
- psess: &ParseSess,
-) -> Option<(MetaItemInner, Vec<(AttrItem, Span)>)> {
- const CFG_ATTR_GRAMMAR_HELP: &str = "#[cfg_attr(condition, attribute, other_attribute, ...)]";
- const CFG_ATTR_NOTE_REF: &str = "for more information, visit \
- <https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute>";
-
- match cfg_attr.get_normal_item().args {
- ast::AttrArgs::Delimited(ast::DelimArgs { dspan, delim, ref tokens })
- if !tokens.is_empty() =>
- {
- check_cfg_attr_bad_delim(psess, dspan, delim);
- match parse_in(psess, tokens.clone(), "`cfg_attr` input", |p| p.parse_cfg_attr()) {
- Ok(r) => return Some(r),
- Err(e) => {
- e.with_help(format!("the valid syntax is `{CFG_ATTR_GRAMMAR_HELP}`"))
- .with_note(CFG_ATTR_NOTE_REF)
- .emit();
- }
- }
- }
- _ => {
- psess.dcx().emit_err(errors::MalformedCfgAttr {
- span: cfg_attr.span,
- sugg: CFG_ATTR_GRAMMAR_HELP,
- });
- }
- }
- None
-}
-
-fn check_cfg_attr_bad_delim(psess: &ParseSess, span: DelimSpan, delim: Delimiter) {
- if let Delimiter::Parenthesis = delim {
- return;
- }
- psess.dcx().emit_err(errors::CfgAttrBadDelim {
- span: span.entire(),
- sugg: errors::MetaBadDelimSugg { open: span.open, close: span.close },
- });
-}

compiler/rustc_parse/src/parser/attr.rs

@@ -377,27 +377,6 @@ impl<'a> Parser<'a> {
  Ok(lit)
  }
 
- /// Parses `cfg_attr(pred, attr_item_list)` where `attr_item_list` is comma-delimited.
- pub fn parse_cfg_attr(
- &mut self,
- ) -> PResult<'a, (ast::MetaItemInner, Vec<(ast::AttrItem, Span)>)> {
- let cfg_predicate = self.parse_meta_item_inner()?;
- self.expect(exp!(Comma))?;
-
- // Presumably, the majority of the time there will only be one attr.
- let mut expanded_attrs = Vec::with_capacity(1);
- while self.token != token::Eof {
- let lo = self.token.span;
- let item = self.parse_attr_item(ForceCollect::Yes)?;
- expanded_attrs.push((item, lo.to(self.prev_token.span)));
- if !self.eat(exp!(Comma)) {
- break;
- }
- }
-
- Ok((cfg_predicate, expanded_attrs))
- }
-
  /// Matches `COMMASEP(meta_item_inner)`.
  pub fn parse_meta_seq_top(&mut self) -> PResult<'a, ThinVec<ast::MetaItemInner>> {
  // Presumably, the majority of the time there will only be one attr.