@@ -368,6 +368,7 @@ struct ExtractorNodeFieldInfo {
     name: String,
     method: String,
     snake_case_ty: String,
+    attributes: bool,
     string: bool,
     predicate: bool,
     optional: bool,
@@ -403,9 +404,7 @@ fn enum_to_extractor_info(node: &AstEnumSrc) -> ExtractorEnumInfo {
                 let name = class_name(v);
                 let snake_case_name = to_lower_snake_case(v);
                 let emission = match v.as_str() {
-                    "ParenExpr" => {
-                        "{ if self.should_be_excluded(inner) { return None; } inner.expr().and_then(|x| self.emit_expr(&x)) }".to_owned()
-                    }
+                    "ParenExpr" => "self.emit_parenthesized_expr(inner)".to_owned(),
                     "ParenPat" => "inner.pat().and_then(|x| self.emit_pat(&x))".to_owned(),
                     _ => format!("self.emit_{snake_case_name}(inner).map(Into::into)"),
                 };
@@ -423,6 +422,7 @@ fn enum_to_extractor_info(node: &AstEnumSrc) -> ExtractorEnumInfo {
 
 fn field_info_to_extractor_info(name: &str, field: &FieldInfo) -> ExtractorNodeFieldInfo {
     let name = property_name(name, &field.name);
+    let attributes = name == "attrs";
     match &field.ty {
         FieldType::String => ExtractorNodeFieldInfo {
             name,
@@ -451,6 +451,7 @@ fn field_info_to_extractor_info(name: &str, field: &FieldInfo) -> ExtractorNodeF
         },
         FieldType::List(ty) => ExtractorNodeFieldInfo {
             name,
+            attributes,
             method: if ty == "AnyAttr" {
                 "attrs_with_doc".to_owned()
             } else {
 
@@ -51,10 +51,20 @@ impl Translator<'_> {
             {{/body}}
             ;
         {{/fields}}
+        {{#fields}}
+        {{#attributes}}
+        let attrs = self.merge_parenthesized_expr_attrs(attrs);
+        {{/attributes}}
+        {{/fields}}
         let label = self.trap.emit(generated::{{name}} {
             id: TrapId::Star,
             {{#fields}}
+            {{#attributes}}
+            attrs,
+            {{/attributes}}
+            {{^attributes}}
             {{name}},
+            {{/attributes}}
             {{/fields}}
         });
         self.emit_location(label, node);
 
@@ -132,6 +132,7 @@ pub struct Translator<'db> {
     pub semantics: Option<&'db Semantics<'db, RootDatabase>>,
     source_kind: SourceKind,
     pub(crate) macro_context_depth: usize,
+    parenthesized_expr_attrs: Vec<Label<generated::AnyAttr>>,
     diagnostic_count: usize,
     /// When emitting a reconstructed built-in derive expansion, holds the span map of the
     /// synthesized syntax tree. Those nodes are not registered in the semantics cache, so
@@ -162,6 +163,7 @@ impl<'db> Translator<'db> {
             semantics: semantic_info.map(|i| i.semantics),
             source_kind,
             macro_context_depth: 0,
+            parenthesized_expr_attrs: Vec::new(),
             diagnostic_count: 0,
             builtin_derive_span_map: None,
         }
@@ -523,6 +525,34 @@ impl<'db> Translator<'db> {
         })
     }
 
+    pub(crate) fn emit_parenthesized_expr(
+        &mut self,
+        node: &ast::ParenExpr,
+    ) -> Option<Label<generated::Expr>> {
+        if self.should_be_excluded(node) {
+            return None;
+        }
+
+        let pending_attrs = self.parenthesized_expr_attrs.len();
+        let attrs = node
+            .attrs_with_doc()
+            .filter_map(|attr| self.emit_any_attr(&attr))
+            .collect::<Vec<_>>();
+        self.parenthesized_expr_attrs.extend(attrs);
+        let result = node.expr().and_then(|expr| self.emit_expr(&expr));
+        self.parenthesized_expr_attrs.truncate(pending_attrs);
+        result
+    }
+
+    pub(crate) fn merge_parenthesized_expr_attrs(
+        &mut self,
+        mut attrs: Vec<Label<generated::AnyAttr>>,
+    ) -> Vec<Label<generated::AnyAttr>> {
+        let mut parent_attrs = std::mem::take(&mut self.parenthesized_expr_attrs);
+        parent_attrs.append(&mut attrs);
+        parent_attrs
+    }
+
     pub(crate) fn should_skip_bodies(&self) -> bool {
         self.source_kind == SourceKind::Library
     }