Make cfg and cfg_attr trace attributes into early parsed attributes

Author: JonathanBrouwer

compiler/rustc_ast/src/ast.rs

@@ -3446,6 +3446,8 @@ impl AttrItemKind {
 /// When adding new early parsed attributes, consider whether they should be pretty printed.
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
 pub enum EarlyParsedAttribute {
+    CfgTrace(CfgEntry),
+    CfgAttrTrace,
 }
 
 impl AttrItem {

compiler/rustc_ast/src/attr/data_structures.rs

@@ -0,0 +1,101 @@
+use std::fmt;
+
+use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+use rustc_span::{Span, Symbol};
+use thin_vec::ThinVec;
+
+use crate::attr::version::RustcVersion;
+
+#[derive(Encodable, Decodable, Clone, Debug, PartialEq, Eq, Hash, HashStable_Generic)]
+pub enum CfgEntry {
+    All(ThinVec<CfgEntry>, Span),
+    Any(ThinVec<CfgEntry>, Span),
+    Not(Box<CfgEntry>, Span),
+    Bool(bool, Span),
+    NameValue { name: Symbol, value: Option<Symbol>, span: Span },
+    Version(Option<RustcVersion>, Span),
+}
+
+impl CfgEntry {
+    pub fn lower_spans(&mut self, lower_span: impl Copy + Fn(Span) -> Span) {
+        match self {
+            CfgEntry::All(subs, span) | CfgEntry::Any(subs, span) => {
+                *span = lower_span(*span);
+                subs.iter_mut().for_each(|sub| sub.lower_spans(lower_span));
+            }
+            CfgEntry::Not(sub, span) => {
+                *span = lower_span(*span);
+                sub.lower_spans(lower_span);
+            }
+            CfgEntry::Bool(_, span)
+            | CfgEntry::NameValue { span, .. }
+            | CfgEntry::Version(_, span) => {
+                *span = lower_span(*span);
+            }
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        let (Self::All(_, span)
+        | Self::Any(_, span)
+        | Self::Not(_, span)
+        | Self::Bool(_, span)
+        | Self::NameValue { span, .. }
+        | Self::Version(_, span)) = self;
+        *span
+    }
+
+    /// Same as `PartialEq` but doesn't check spans and ignore order of cfgs.
+    pub fn is_equivalent_to(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::All(a, _), Self::All(b, _)) | (Self::Any(a, _), Self::Any(b, _)) => {
+                a.len() == b.len() && a.iter().all(|a| b.iter().any(|b| a.is_equivalent_to(b)))
+            }
+            (Self::Not(a, _), Self::Not(b, _)) => a.is_equivalent_to(b),
+            (Self::Bool(a, _), Self::Bool(b, _)) => a == b,
+            (
+                Self::NameValue { name: name1, value: value1, .. },
+                Self::NameValue { name: name2, value: value2, .. },
+            ) => name1 == name2 && value1 == value2,
+            (Self::Version(a, _), Self::Version(b, _)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl fmt::Display for CfgEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fn write_entries(
+            name: &str,
+            entries: &[CfgEntry],
+            f: &mut fmt::Formatter<'_>,
+        ) -> fmt::Result {
+            write!(f, "{name}(")?;
+            for (nb, entry) in entries.iter().enumerate() {
+                if nb != 0 {
+                    f.write_str(", ")?;
+                }
+                entry.fmt(f)?;
+            }
+            f.write_str(")")
+        }
+        match self {
+            Self::All(entries, _) => write_entries("all", entries, f),
+            Self::Any(entries, _) => write_entries("any", entries, f),
+            Self::Not(entry, _) => write!(f, "not({entry})"),
+            Self::Bool(value, _) => write!(f, "{value}"),
+            Self::NameValue { name, value, .. } => {
+                match value {
+                    // We use `as_str` and debug display to have characters escaped and `"`
+                    // characters surrounding the string.
+                    Some(value) => write!(f, "{name} = {:?}", value.as_str()),
+                    None => write!(f, "{name}"),
+                }
+            }
+            Self::Version(version, _) => match version {
+                Some(version) => write!(f, "{version}"),
+                None => Ok(()),
+            },
+        }
+    }
+}

compiler/rustc_hir/src/version.rs compiler/rustc_ast/src/attr/version.rscompiler/rustc_hir/src/version.rs renamed to compiler/rustc_ast/src/attr/version.rs

@@ -1,16 +1,10 @@
-use std::borrow::Cow;
 use std::fmt::{self, Display};
 use std::sync::OnceLock;
 
-use rustc_error_messages::{DiagArgValue, IntoDiagArg};
-use rustc_macros::{
-    BlobDecodable, Encodable, HashStable_Generic, PrintAttribute, current_rustc_version,
-};
-
-use crate::attrs::PrintAttribute;
+use rustc_macros::{BlobDecodable, Encodable, HashStable_Generic, current_rustc_version};
 
 #[derive(Encodable, BlobDecodable, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[derive(HashStable_Generic, PrintAttribute)]
+#[derive(HashStable_Generic)]
 pub struct RustcVersion {
     pub major: u16,
     pub minor: u16,
@@ -47,9 +41,3 @@ impl Display for RustcVersion {
         write!(formatter, "{}.{}.{}", self.major, self.minor, self.patch)
     }
 }
-
-impl IntoDiagArg for RustcVersion {
-    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
-        DiagArgValue::Str(Cow::Owned(self.to_string()))
-    }
-}

compiler/rustc_attr_parsing/src/early_parsed.rs

@@ -0,0 +1,53 @@
+use rustc_ast::EarlyParsedAttribute;
+use rustc_ast::attr::data_structures::CfgEntry;
+use rustc_hir::Attribute;
+use rustc_hir::attrs::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+use thin_vec::ThinVec;
+
+pub(crate) const EARLY_PARSED_ATTRIBUTES: &[&[Symbol]] =
+    &[&[sym::cfg_trace], &[sym::cfg_attr_trace]];
+
+/// This struct contains the state necessary to convert early parsed attributes to hir attributes
+/// The only conversion that really happens here is that multiple early parsed attributes are
+/// merged into a single hir attribute, representing their combined state.
+/// FIXME: We should make this a nice and extendable system if this is going to be used more often
+#[derive(Default)]
+pub(crate) struct EarlyParsedState {
+    /// Attribute state for `#[cfg]` trace attributes
+    cfg_trace: ThinVec<(CfgEntry, Span)>,
+
+    /// Attribute state for `#[cfg_attr]` trace attributes
+    /// The arguments of these attributes is no longer relevant for any later passes, only their presence.
+    /// So we discard the arguments here.
+    cfg_attr_trace: bool,
+}
+
+impl EarlyParsedState {
+    pub(crate) fn accept_early_parsed_attribute(
+        &mut self,
+        attr_span: Span,
+        lower_span: impl Copy + Fn(Span) -> Span,
+        parsed: &EarlyParsedAttribute,
+    ) {
+        match parsed {
+            EarlyParsedAttribute::CfgTrace(cfg) => {
+                let mut cfg = cfg.clone();
+                cfg.lower_spans(lower_span);
+                self.cfg_trace.push((cfg, attr_span));
+            }
+            EarlyParsedAttribute::CfgAttrTrace => {
+                self.cfg_attr_trace = true;
+            }
+        }
+    }
+
+    pub(crate) fn finalize_early_parsed_attributes(self, attributes: &mut Vec<Attribute>) {
+        if !self.cfg_trace.is_empty() {
+            attributes.push(Attribute::Parsed(AttributeKind::CfgTrace(self.cfg_trace)));
+        }
+        if self.cfg_attr_trace {
+            attributes.push(Attribute::Parsed(AttributeKind::CfgAttrTrace));
+        }
+    }
+}

compiler/rustc_attr_parsing/src/interface.rs

@@ -2,7 +2,7 @@ use std::convert::identity;
 
 use rustc_ast as ast;
 use rustc_ast::token::DocFragmentKind;
-use rustc_ast::{AttrStyle, NodeId, Safety};
+use rustc_ast::{AttrItemKind, AttrStyle, NodeId, Safety};
 use rustc_errors::DiagCtxtHandle;
 use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::attrs::AttributeKind;
@@ -13,6 +13,7 @@ use rustc_session::lint::BuiltinLintDiag;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 
 use crate::context::{AcceptContext, FinalizeContext, SharedContext, Stage};
+use crate::early_parsed::{EARLY_PARSED_ATTRIBUTES, EarlyParsedState};
 use crate::parser::{ArgParser, PathParser, RefPathParser};
 use crate::session_diagnostics::ParsedDescription;
 use crate::{Early, Late, OmitDoc, ShouldEmit};
@@ -146,8 +147,12 @@ impl<'sess> AttributeParser<'sess, Early> {
             normal_attr.item.path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>();
 
         let path = AttrPath::from_ast(&normal_attr.item.path, identity);
-        let args =
-            ArgParser::from_attr_args(&normal_attr.item.args, &parts, &sess.psess, emit_errors)?;
+        let args = ArgParser::from_attr_args(
+            &normal_attr.item.args.unparsed_ref().unwrap(),
+            &parts,
+            &sess.psess,
+            emit_errors,
+        )?;
         Self::parse_single_args(
             sess,
             attr.span,
@@ -263,12 +268,12 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         target_id: S::Id,
         target: Target,
         omit_doc: OmitDoc,
-
         lower_span: impl Copy + Fn(Span) -> Span,
         mut emit_lint: impl FnMut(AttributeLint<S::Id>),
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();
         let mut attr_paths: Vec<RefPathParser<'_>> = Vec::new();
+        let mut early_parsed_state = EarlyParsedState::default();
 
         for attr in attrs {
             // If we're only looking for a single attribute, skip all the ones we don't care about.
@@ -288,6 +293,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                 continue;
             }
 
+            let attr_span = lower_span(attr.span);
             match &attr.kind {
                 ast::AttrKind::DocComment(comment_kind, symbol) => {
                     if omit_doc == OmitDoc::Skip {
@@ -297,14 +303,23 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                     attributes.push(Attribute::Parsed(AttributeKind::DocComment {
                         style: attr.style,
                         kind: DocFragmentKind::Sugared(*comment_kind),
-                        span: lower_span(attr.span),
+                        span: attr_span,
                         comment: *symbol,
                     }))
                 }
                 ast::AttrKind::Normal(n) => {
                     attr_paths.push(PathParser(&n.item.path));
                     let attr_path = AttrPath::from_ast(&n.item.path, lower_span);
 
+                    let args = match &n.item.args {
+                        AttrItemKind::Unparsed(args) => args,
+                        AttrItemKind::Parsed(parsed) => {
+                            early_parsed_state
+                                .accept_early_parsed_attribute(attr_span, lower_span, parsed);
+                            continue;
+                        }
+                    };
+
                     self.check_attribute_safety(
                         &attr_path,
                         lower_span(n.item.span()),
@@ -318,7 +333,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
                     if let Some(accepts) = S::parsers().accepters.get(parts.as_slice()) {
                         let Some(args) = ArgParser::from_attr_args(
-                            &n.item.args,
+                            args,
                             &parts,
                             &self.sess.psess,
                             self.stage.should_emit(),
@@ -351,7 +366,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             attributes.push(Attribute::Parsed(AttributeKind::DocComment {
                                 style: attr.style,
                                 kind: DocFragmentKind::Raw(nv.value_span),
-                                span: attr.span,
+                                span: attr_span,
                                 comment,
                             }));
                             continue;
@@ -365,7 +380,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                     target_id,
                                     emit_lint: &mut emit_lint,
                                 },
-                                attr_span: lower_span(attr.span),
+                                attr_span,
                                 inner_span: lower_span(n.item.span()),
                                 attr_style: attr.style,
                                 parsed_description: ParsedDescription::Attribute,
@@ -396,17 +411,18 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
                         attributes.push(Attribute::Unparsed(Box::new(AttrItem {
                             path: attr_path.clone(),
-                            args: self.lower_attr_args(&n.item.args, lower_span),
+                            args: self
+                                .lower_attr_args(n.item.args.unparsed_ref().unwrap(), lower_span),
                             id: HashIgnoredAttrId { attr_id: attr.id },
                             style: attr.style,
-                            span: lower_span(attr.span),
+                            span: attr_span,
                         })));
                     }
                 }
             }
         }
 
-        let mut parsed_attributes = Vec::new();
+        early_parsed_state.finalize_early_parsed_attributes(&mut attributes);
         for f in &S::parsers().finalizers {
             if let Some(attr) = f(&mut FinalizeContext {
                 shared: SharedContext {
@@ -417,18 +433,16 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                 },
                 all_attrs: &attr_paths,
             }) {
-                parsed_attributes.push(Attribute::Parsed(attr));
+                attributes.push(Attribute::Parsed(attr));
             }
         }
 
-        attributes.extend(parsed_attributes);
-
         attributes
     }
 
     /// Returns whether there is a parser for an attribute with this name
     pub fn is_parsed_attribute(path: &[Symbol]) -> bool {
-        Late::parsers().accepters.contains_key(path)
+        Late::parsers().accepters.contains_key(path) || EARLY_PARSED_ATTRIBUTES.contains(&path)
     }
 
     fn lower_attr_args(&self, args: &ast::AttrArgs, lower_span: impl Fn(Span) -> Span) -> AttrArgs {

compiler/rustc_attr_parsing/src/lib.rs

@@ -99,6 +99,7 @@ mod interface;
 /// like lists or name-value pairs.
 pub mod parser;
 
+mod early_parsed;
 mod safety;
 mod session_diagnostics;
 mod target_checking;

compiler/rustc_attr_parsing/src/safety.rs

@@ -4,7 +4,7 @@ use rustc_hir::AttrPath;
 use rustc_hir::lints::{AttributeLint, AttributeLintKind};
 use rustc_session::lint::LintId;
 use rustc_session::lint::builtin::UNSAFE_ATTR_OUTSIDE_UNSAFE;
-use rustc_span::{Span, sym};
+use rustc_span::Span;
 
 use crate::context::Stage;
 use crate::{AttributeParser, ShouldEmit};
@@ -23,11 +23,6 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         }
 
         let name = (attr_path.segments.len() == 1).then_some(attr_path.segments[0]);
-        if let Some(name) = name
-            && [sym::cfg_trace, sym::cfg_attr_trace].contains(&name)
-        {
-            return;
-        }
 
         // FIXME: We should retrieve this information from the attribute parsers instead of from `BUILTIN_ATTRIBUTE_MAP`
         let builtin_attr_info = name.and_then(|name| BUILTIN_ATTRIBUTE_MAP.get(&name));

compiler/rustc_expand/src/config.rs

@@ -7,8 +7,8 @@ use rustc_ast::tokenstream::{
     AttrTokenStream, AttrTokenTree, LazyAttrTokenStream, Spacing, TokenTree,
 };
 use rustc_ast::{
-    self as ast, AttrKind, AttrStyle, Attribute, HasAttrs, HasTokens, MetaItem, MetaItemInner,
-    NodeId, NormalAttr,
+    self as ast, AttrItemKind, AttrKind, AttrStyle, Attribute, EarlyParsedAttribute, HasAttrs,
+    HasTokens, MetaItem, MetaItemInner, NodeId, NormalAttr,
 };
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
@@ -288,7 +288,9 @@ impl<'a> StripUnconfigured<'a> {
     pub(crate) fn expand_cfg_attr(&self, cfg_attr: &Attribute, recursive: bool) -> Vec<Attribute> {
         // A trace attribute left in AST in place of the original `cfg_attr` attribute.
         // It can later be used by lints or other diagnostics.
-        let trace_attr = attr_into_trace(cfg_attr.clone(), sym::cfg_attr_trace);
+        let mut trace_attr = cfg_attr.clone();
+        trace_attr.replace_args(AttrItemKind::Parsed(EarlyParsedAttribute::CfgAttrTrace));
+        let trace_attr = attr_into_trace(trace_attr, sym::cfg_attr_trace);
 
         let Some((cfg_predicate, expanded_attrs)) =
             rustc_attr_parsing::parse_cfg_attr(cfg_attr, &self.sess, self.features)