Rust: Remove parenthesized expression and pattern nodes

Extract parenthesized expressions and patterns as their inner entities, and update QL consumers and generated schema. Preserve attributes from parentheses and update query expectations for the resulting behavior.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: hvitved

rust/ast-generator/src/main.rs

@@ -76,6 +76,8 @@ fn should_enum_be_skipped(name: &str) -> bool {
 fn should_node_be_skipped(name: &str) -> bool {
     name == "TypeAnchor" // we flatten TypeAnchor into PathSegment in the extractor
     || name == "MacroStmts" // we workaround a getter bug in the extractor
+    || name == "ParenExpr" // parenthesized expressions are extracted as their inner expression
+    || name == "ParenPat" // parenthesized patterns are extracted as their inner pattern
 }
 
 fn should_node_be_skipped_in_extractor(name: &str) -> bool {
@@ -349,6 +351,7 @@ struct EnumVariantInfo {
     name: String,
     snake_case_name: String,
     variant_ast_name: String,
+    emission: String,
 }
 
 #[derive(Serialize)]
@@ -365,6 +368,7 @@ struct ExtractorNodeFieldInfo {
     name: String,
     method: String,
     snake_case_ty: String,
+    attributes: bool,
     string: bool,
     predicate: bool,
     optional: bool,
@@ -399,10 +403,16 @@ fn enum_to_extractor_info(node: &AstEnumSrc) -> ExtractorEnumInfo {
             .map(|v| {
                 let name = class_name(v);
                 let snake_case_name = to_lower_snake_case(v);
+                let emission = match v.as_str() {
+                    "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)"),
+                };
                 EnumVariantInfo {
                     name,
                     snake_case_name,
                     variant_ast_name: v.to_string(),
+                    emission,
                 }
             })
             .collect(),
@@ -412,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,
@@ -440,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 {

rust/ast-generator/templates/extractor.mustache

@@ -18,7 +18,7 @@ impl Translator<'_> {
         {{>pre_emission}}
         let label = match node {
             {{#variants}}
-            ast::{{ast_name}}::{{variant_ast_name}}(inner) => self.emit_{{snake_case_name}}(inner).map(Into::into),
+            ast::{{ast_name}}::{{variant_ast_name}}(inner) => {{{emission}}},
             {{/variants}}
         }?;
         {{>post_emission}}
@@ -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);

rust/extractor/src/generated/.generated.list

@@ -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
     }