Replace "early parsed" terminology

AST attributes use "early parsed"/"parsed" terminology to refer to the
`CfgTrace` and `CfgAttrTrace` attributes. I think this terminology is
meant to echo the terminology used for HIR attributes, i.e.
`hir::Attribute::{Parsed,Unparsed}`, probably because
`hir::Attribute::Parsed` is used for attributes that aren't stored in a
token-based form.

But this naming is misleading. "Early parsed" attributes aren't parsed
at all because they are inserted by the compiler and cannot be written
in source code. There are also two comments that claim that these
attributes are kept in parsed form "so they don't have to be reparsed
every time they're used, for performance", which is simply incorrect.

This commit renames these as "synthetic" attributes, which better
reflects their nature. The commit also fixes the incorrect comments.

Note that `is_parsed_attribute` is unchanged, because it refers to the
HIR attribute meaning. (And the removal of the synthetic attributes from
it in the previous commit is now more obviously correct.)

Author: nnethercote

compiler/rustc_ast/src/ast.rs

@@ -3415,13 +3415,11 @@ pub struct Attribute {
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub enum AttrKind {
-    /// A normal (non-doc comment) attribute, with attributes in unparsed form.
+    /// A normal attribute.
     Normal(Box<NormalAttr>),
 
-    /// A normal (non-doc comment) attribute, with attributes in parsed form, so they don't have to
-    /// be reparsed every time they're used, for performance. Only used for a small number of
-    /// attribute kinds.
-    Parsed(Box<EarlyParsedAttribute>),
+    /// A synthetic attribute inserted by the compiler.
+    Synthetic(Box<SyntheticAttr>),
 
     /// A doc comment (e.g. `/// ...`, `//! ...`, `/** ... */`, `/*! ... */`).
     /// Doc attributes (e.g. `#[doc="..."]`) are represented with the `Normal`
@@ -3457,29 +3455,29 @@ pub struct AttrItem {
     pub args: AttrArgs,
 }
 
-/// Some attributes are stored in parsed form in the AST.
-/// This is done for performance reasons, so the attributes don't need to be reparsed on every use.
+/// Synthetic attributes are inserted by the compiler and cannot be written in source code. They
+/// receive special treatment in various ways because they must not affect observable behaviour:
+/// they are invisible to proc macros, cannot be pretty-printed, and are unable to re-enter the
+/// parser.
 #[derive(Clone, Encodable, Decodable, Debug, StableHash)]
-pub enum EarlyParsedAttribute {
-    /// This special attribute is added by the compiler when a `cfg` attribute is expanded so that
+pub enum SyntheticAttr {
+    /// This synthetic attribute is added by the compiler when a `cfg` attribute is expanded so that
     /// subsequent code can tell that conditional compilation occurred. A `#[cfg(pred)]` with a
     /// true predicate is replaced by a synthetic `CfgTrace` attribute that records the parsed
     /// predicate. A `#[cfg(pred)]` with a false predicate leaves no trace because there is no node
     /// left to annotate.
     ///
     /// The attribute is used for some diagnostics, by rustdoc (for detecting feature usage), and
-    /// by some clippy lints. It is treated specially in various places because it must not be
-    /// observable in any way that could change behaviour. For example, it is never pretty-printed
-    /// and it is hidden from proc macros.
+    /// by some clippy lints.
     CfgTrace(CfgEntry),
 
-    /// This special attribute is added by the compiler when a `cfg_attr` attribute is expanded so
+    /// This synthetic attribute is added by the compiler when a `cfg_attr` attribute is expanded so
     /// that subsequent code can tell that conditional compilation occurred. A `#[cfg_attr(pred,
     /// attrs)]` is replaced by a synthetic `CfgAttrTrace` attribute whether the predicate
     /// evaluated true or not (or even failed to parse). The `pred` and `attrs` are not recorded
     /// because they are not needed.
     ///
-    /// In all other respects, it is the same as `CfgTrace`.
+    /// The attribute is used by some clippy lints.
     CfgAttrTrace,
 }
 

compiler/rustc_ast/src/ast_traits.rs

@@ -170,13 +170,13 @@ impl HasTokens for Attribute {
     fn tokens(&self) -> Option<&LazyAttrTokenStream> {
         match &self.kind {
             AttrKind::Normal(normal) => normal.tokens.as_ref(),
-            AttrKind::Parsed(..) | AttrKind::DocComment(..) => unreachable!(),
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => unreachable!(),
         }
     }
     fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> {
         Some(match &mut self.kind {
             AttrKind::Normal(normal) => &mut normal.tokens,
-            AttrKind::Parsed(..) | AttrKind::DocComment(..) => unreachable!(),
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => unreachable!(),
         })
     }
 }

compiler/rustc_ast/src/attr/mod.rs

@@ -13,8 +13,8 @@ use thin_vec::{ThinVec, thin_vec};
 
 use crate::ast::{
     AttrArgs, AttrId, AttrItem, AttrKind, AttrStyle, AttrVec, Attribute, DUMMY_NODE_ID, DelimArgs,
-    EarlyParsedAttribute, Expr, ExprKind, LitKind, MetaItem, MetaItemInner, MetaItemKind,
-    MetaItemLit, NormalAttr, Path, PathSegment, Safety,
+    Expr, ExprKind, LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NormalAttr, Path,
+    PathSegment, Safety, SyntheticAttr,
 };
 use crate::token::{
     self, CommentKind, Delimiter, DocFragmentKind, InvisibleOrigin, MetaVarKind, Token,
@@ -61,16 +61,16 @@ impl Attribute {
     pub fn get_normal_item(&self) -> &AttrItem {
         match &self.kind {
             AttrKind::Normal(normal) => &normal.item,
-            AttrKind::Parsed(..) | AttrKind::DocComment(..) => unreachable!(),
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => unreachable!(),
         }
     }
 
-    pub fn convert_normal_to_parsed(&mut self, early_parsed_attribute: EarlyParsedAttribute) {
+    pub fn convert_normal_to_synthetic(&mut self, synthetic_attr: SyntheticAttr) {
         match self.kind {
             AttrKind::Normal(..) => {
-                self.kind = AttrKind::Parsed(Box::new(early_parsed_attribute));
+                self.kind = AttrKind::Synthetic(Box::new(synthetic_attr));
             }
-            AttrKind::Parsed(..) | AttrKind::DocComment(..) => unreachable!(),
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => unreachable!(),
         }
     }
 }
@@ -86,7 +86,7 @@ impl AttributeExt for Attribute {
                 AttrArgs::Eq { expr, .. } => Some(expr.span),
                 _ => None,
             },
-            AttrKind::Parsed(..) | AttrKind::DocComment(..) => None,
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => None,
         }
     }
 
@@ -95,36 +95,36 @@ impl AttributeExt for Attribute {
     /// a doc comment) will return `false`.
     fn is_doc_comment(&self) -> Option<Span> {
         match self.kind {
-            AttrKind::Normal(..) | AttrKind::Parsed(..) => None,
+            AttrKind::Normal(..) | AttrKind::Synthetic(..) => None,
             AttrKind::DocComment(..) => Some(self.span),
         }
     }
 
     /// For a single-segment attribute, returns its name; otherwise, returns `None`.
     fn name(&self) -> Option<Symbol> {
-        use EarlyParsedAttribute::*;
+        use SyntheticAttr::*;
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.name(),
-            AttrKind::Parsed(CfgTrace(_) | CfgAttrTrace) => None,
+            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => None,
             AttrKind::DocComment(..) => None,
         }
     }
 
     fn symbol_path(&self) -> Option<SmallVec<[Symbol; 1]>> {
-        use EarlyParsedAttribute::*;
+        use SyntheticAttr::*;
         match &self.kind {
             AttrKind::Normal(normal) => {
                 Some(normal.item.path.segments.iter().map(|i| i.ident.name).collect())
             }
-            AttrKind::Parsed(CfgTrace(_) | CfgAttrTrace) => None,
+            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => None,
             AttrKind::DocComment(_, _) => None,
         }
     }
 
     fn path_span(&self) -> Option<Span> {
         match &self.kind {
             AttrKind::Normal(attr) => Some(attr.item.path.span),
-            AttrKind::Parsed(..) => unreachable!(),
+            AttrKind::Synthetic(..) => unreachable!(),
             AttrKind::DocComment(_, _) => None,
         }
     }
@@ -141,7 +141,7 @@ impl AttributeExt for Attribute {
                         .zip(name)
                         .all(|(s, n)| s.args.is_none() && s.ident.name == *n)
             }
-            AttrKind::Parsed(..) => false,
+            AttrKind::Synthetic(..) => false,
             AttrKind::DocComment(..) => false,
         }
     }
@@ -153,7 +153,7 @@ impl AttributeExt for Attribute {
     fn is_word(&self) -> bool {
         match &self.kind {
             AttrKind::Normal(normal) => matches!(normal.item.args, AttrArgs::Empty),
-            AttrKind::Parsed(..) => unreachable!(),
+            AttrKind::Synthetic(..) => unreachable!(),
             AttrKind::DocComment(..) => false,
         }
     }
@@ -168,7 +168,7 @@ impl AttributeExt for Attribute {
     fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.meta_item_list(),
-            AttrKind::Parsed(..) => None,
+            AttrKind::Synthetic(..) => None,
             AttrKind::DocComment(..) => None,
         }
     }
@@ -191,7 +191,7 @@ impl AttributeExt for Attribute {
     fn value_str(&self) -> Option<Symbol> {
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.value_str(),
-            AttrKind::Parsed(..) => unreachable!(),
+            AttrKind::Synthetic(..) => unreachable!(),
             AttrKind::DocComment(..) => None,
         }
     }
@@ -211,7 +211,7 @@ impl AttributeExt for Attribute {
             {
                 Some((value, DocFragmentKind::Raw(value_span)))
             }
-            AttrKind::Normal(..) | AttrKind::Parsed(..) => None,
+            AttrKind::Normal(..) | AttrKind::Synthetic(..) => None,
         }
     }
 
@@ -280,15 +280,15 @@ impl Attribute {
     pub fn meta(&self) -> Option<MetaItem> {
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.meta(self.span),
-            AttrKind::Parsed(..) => None,
+            AttrKind::Synthetic(..) => None,
             AttrKind::DocComment(..) => None,
         }
     }
 
     pub fn meta_kind(&self) -> Option<MetaItemKind> {
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.meta_kind(),
-            AttrKind::Parsed(..) => unreachable!(),
+            AttrKind::Synthetic(..) => unreachable!(),
             AttrKind::DocComment(..) => None,
         }
     }
@@ -301,7 +301,7 @@ impl Attribute {
                 .unwrap_or_else(|| panic!("attribute is missing tokens: {self:?}"))
                 .to_attr_token_stream()
                 .to_token_trees(),
-            AttrKind::Parsed(..) => vec![],
+            AttrKind::Synthetic(..) => vec![],
             AttrKind::DocComment(comment_kind, data) => vec![TokenTree::token_alone(
                 token::DocComment(comment_kind, self.style, data),
                 self.span,

compiler/rustc_ast/src/visit.rs

@@ -365,7 +365,6 @@ macro_rules! common_visitor_and_walkers {
             crate::token::LitKind,
             crate::tokenstream::LazyAttrTokenStream,
             crate::tokenstream::TokenStream,
-            EarlyParsedAttribute,
             Movability,
             Mutability,
             Pinnedness,
@@ -374,6 +373,7 @@ macro_rules! common_visitor_and_walkers {
             rustc_span::ErrorGuaranteed,
             std::borrow::Cow<'_, str>,
             Symbol,
+            SyntheticAttr,
             u8,
             usize,
         );

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -514,7 +514,7 @@ impl<'a> AstValidator<'a> {
     }
 
     fn check_decl_attrs(&self, fn_decl: &FnDecl) {
-        use EarlyParsedAttribute::*;
+        use SyntheticAttr::*;
         fn_decl
             .inputs
             .iter()
@@ -525,7 +525,7 @@ impl<'a> AstValidator<'a> {
                         [sym::allow, sym::deny, sym::expect, sym::forbid, sym::splat, sym::warn];
                     !attr.has_any_name(&arr) && rustc_attr_parsing::is_builtin_attr(&normal.item)
                 }
-                AttrKind::Parsed(CfgTrace(_) | CfgAttrTrace) => false,
+                AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => false,
                 AttrKind::DocComment(..) => true,
             })
             .for_each(|attr| {

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -670,9 +670,9 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     }
 
     fn print_attribute_inline(&mut self, attr: &ast::Attribute, is_inline: bool) -> bool {
-        use ast::EarlyParsedAttribute::*;
+        use ast::SyntheticAttr::*;
         match attr.kind {
-            AttrKind::Parsed(CfgTrace(_) | CfgAttrTrace) => {
+            AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace) => {
                 // These are internal synthetic attributes with no syntax, so avoid printing them
                 // to keep the printed code reasonably parse-able.
                 return false;
@@ -692,7 +692,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
                 self.print_attr_item(&normal.item, attr.span);
                 self.word("]");
             }
-            ast::AttrKind::Parsed(..) => unreachable!(), // due to early return above
+            ast::AttrKind::Synthetic(..) => unreachable!(), // due to early return above
             ast::AttrKind::DocComment(comment_kind, data) => {
                 self.word(doc_comment_to_string(
                     DocFragmentKind::Sugared(*comment_kind),

compiler/rustc_attr_parsing/src/interface.rs

@@ -20,9 +20,9 @@ use crate::attributes::AttributeSafety;
 use crate::context::{
     ATTRIBUTE_PARSERS, AcceptContext, FinalizeContext, FinalizeFn, SharedContext,
 };
-use crate::early_parsed::EarlyParsedState;
 use crate::parser::{AllowExprMetavar, ArgParser, PathParser, RefPathParser};
 use crate::session_diagnostics::ParsedDescription;
+use crate::synthetic::SyntheticAttrState;
 use crate::{AttributeTemplate, OmitDoc, ShouldEmit};
 
 pub struct EmitAttribute(
@@ -290,7 +290,7 @@ impl<'sess> AttributeParser<'sess> {
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();
         let mut attr_paths: Vec<RefPathParser<'_>> = Vec::new();
-        let mut early_parsed_state = EarlyParsedState::default();
+        let mut synthetic_attr_state = SyntheticAttrState::default();
 
         let mut finalizers: Vec<FinalizeFn> = Vec::with_capacity(attrs.len());
 
@@ -326,8 +326,8 @@ impl<'sess> AttributeParser<'sess> {
                         comment: *symbol,
                     }));
                 }
-                ast::AttrKind::Parsed(parsed) => {
-                    early_parsed_state.accept_early_parsed_attribute(attr_span, lower_span, parsed);
+                ast::AttrKind::Synthetic(synthetic) => {
+                    synthetic_attr_state.accept_synthetic_attr(attr_span, lower_span, synthetic);
                     continue;
                 }
                 ast::AttrKind::Normal(n) => {
@@ -448,7 +448,7 @@ impl<'sess> AttributeParser<'sess> {
             }
         }
 
-        early_parsed_state.finalize_early_parsed_attributes(&mut attributes);
+        synthetic_attr_state.finalize_synthetic_attrs(&mut attributes);
         for f in &finalizers {
             if let Some(attr) = f(&mut FinalizeContext {
                 shared: SharedContext {
@@ -497,7 +497,8 @@ impl<'sess> AttributeParser<'sess> {
         /// The list of attributes that are parsed attributes,
         /// even though they don't have a parser in `Late::parsers()`
         const SPECIAL_ATTRIBUTES: &[&[Symbol]] = &[
-            // Cfg attrs are removed after being early-parsed, so don't need to be in the parser list
+            // Cfg attrs are removed after being converted into synthetic attrs and don't need to
+            // be in the parser list.
             &[sym::cfg],
             &[sym::cfg_attr],
         ];

compiler/rustc_attr_parsing/src/lib.rs

@@ -99,12 +99,12 @@ mod attributes;
 mod check_cfg;
 mod context;
 mod diagnostics;
-mod early_parsed;
 mod interface;
 pub mod parser;
 mod safety;
 mod session_diagnostics;
 mod stability;
+mod synthetic;
 mod target_checking;
 mod template;
 pub mod validate_attr;