Address review comments.

Author: nnethercote

compiler/rustc_ast/src/ast.rs

@@ -3455,10 +3455,10 @@ pub struct AttrItem {
     pub args: AttrArgs,
 }
 
-/// 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.
+/// Synthetic attributes are inserted by the compiler. They cannot be written in source code, and
+/// so cannot be pretty-printed by the AST pretty printer (because its output should be valid Rust
+/// code). They receive special treatment because they must not affect observable language
+/// behaviour: they are invisible to proc macros and are unable to re-enter the parser.
 #[derive(Clone, Encodable, Decodable, Debug, StableHash)]
 pub enum SyntheticAttr {
     /// This synthetic attribute is added by the compiler when a `cfg` attribute is expanded so that

compiler/rustc_ast/src/attr/mod.rs

@@ -65,10 +65,10 @@ impl Attribute {
         }
     }
 
-    pub fn convert_normal_to_synthetic(&mut self, synthetic_attr: SyntheticAttr) {
+    pub fn convert_normal_to_synthetic(self, synthetic_attr: SyntheticAttr) -> Attribute {
         match self.kind {
             AttrKind::Normal(..) => {
-                self.kind = AttrKind::Synthetic(Box::new(synthetic_attr));
+                Attribute { kind: AttrKind::Synthetic(Box::new(synthetic_attr)), ..self }
             }
             AttrKind::Synthetic(..) | AttrKind::DocComment(..) => unreachable!(),
         }
@@ -141,8 +141,7 @@ impl AttributeExt for Attribute {
                         .zip(name)
                         .all(|(s, n)| s.args.is_none() && s.ident.name == *n)
             }
-            AttrKind::Synthetic(..) => false,
-            AttrKind::DocComment(..) => false,
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => false,
         }
     }
 
@@ -168,8 +167,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::Synthetic(..) => None,
-            AttrKind::DocComment(..) => None,
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => None,
         }
     }
 
@@ -280,8 +278,7 @@ impl Attribute {
     pub fn meta(&self) -> Option<MetaItem> {
         match &self.kind {
             AttrKind::Normal(normal) => normal.item.meta(self.span),
-            AttrKind::Synthetic(..) => None,
-            AttrKind::DocComment(..) => None,
+            AttrKind::Synthetic(..) | AttrKind::DocComment(..) => None,
         }
     }
 
@@ -301,6 +298,7 @@ impl Attribute {
                 .unwrap_or_else(|| panic!("attribute is missing tokens: {self:?}"))
                 .to_attr_token_stream()
                 .to_token_trees(),
+            // Empty tokens here ensures synthetic attributes are invisible to proc macros.
             AttrKind::Synthetic(..) => vec![],
             AttrKind::DocComment(comment_kind, data) => vec![TokenTree::token_alone(
                 token::DocComment(comment_kind, self.style, data),

compiler/rustc_expand/src/config.rs

@@ -250,8 +250,7 @@ impl<'a> StripUnconfigured<'a> {
     pub(crate) fn expand_cfg_attr(&self, cfg_attr: &Attribute, recursive: bool) -> Vec<Attribute> {
         // A synthetic trace attribute left in AST in place of the original `cfg_attr` attribute.
         // It can later be used by lints or other diagnostics.
-        let mut trace_attr = cfg_attr.clone();
-        trace_attr.convert_normal_to_synthetic(SyntheticAttr::CfgAttrTrace);
+        let trace_attr = cfg_attr.clone().convert_normal_to_synthetic(SyntheticAttr::CfgAttrTrace);
 
         let Some((cfg_predicate, expanded_attrs)) = rustc_attr_parsing::parse_cfg_attr(
             cfg_attr,

compiler/rustc_expand/src/expand.rs

@@ -2297,8 +2297,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
         if res.as_bool() {
             // A synthetic trace attribute left in AST in place of the original `cfg` attribute.
             // It can later be used by lints or other diagnostics.
-            let mut trace_attr = attr;
-            trace_attr.convert_normal_to_synthetic(SyntheticAttr::CfgTrace(cfg));
+            let trace_attr = attr.convert_normal_to_synthetic(SyntheticAttr::CfgTrace(cfg));
             node.visit_attrs(|attrs| attrs.insert(pos, trace_attr));
         }