Rust: Remove parenthesized expression and pattern nodes

Extract parenthesized expressions and patterns as their inner entities, and update QL consumers and generated schema. Preserve comments and attributes on the unwrapped nodes, with regression tests.

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 {
@@ -133,6 +135,7 @@ fn get_additional_fields(node_name: &str) -> Vec<FieldInfo> {
             FieldInfo::body("body", "TokenTree"),
         ],
         "MacroCall" => vec![FieldInfo::body("token_tree", "TokenTree")],
+        "MacroExpr" | "RecordExpr" => vec![FieldInfo::list("attrs", "AnyAttr")],
         "FormatArgsExpr" => vec![FieldInfo::list("args", "FormatArgsArg")],
         "ArgList" => vec![FieldInfo::list("args", "Expr")],
         "Fn" => vec![FieldInfo::body("body", "BlockExpr")],
@@ -349,6 +352,7 @@ struct EnumVariantInfo {
     name: String,
     snake_case_name: String,
     variant_ast_name: String,
+    emission: String,
 }
 
 #[derive(Serialize)]
@@ -365,6 +369,8 @@ struct ExtractorNodeFieldInfo {
     name: String,
     method: String,
     snake_case_ty: String,
+    attributes: bool,
+    parenthesized_attrs: bool,
     string: bool,
     predicate: bool,
     optional: bool,
@@ -399,10 +405,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" => "self.emit_parenthesized_pat(inner)".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 +424,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 +453,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 {
@@ -453,12 +467,19 @@ fn field_info_to_extractor_info(name: &str, field: &FieldInfo) -> ExtractorNodeF
 }
 fn node_to_extractor_info(node: &AstNodeSrc) -> ExtractorNodeInfo {
     let fields = get_fields(node);
-    let has_attrs = fields.iter().any(|f| f.name == "attrs");
+    let parenthesized_attrs = matches!(node.name.as_str(), "MacroExpr" | "RecordExpr");
     let name = class_name(&node.name);
-    let fields = fields
+    let fields: Vec<_> = fields
         .iter()
         .map(|f| field_info_to_extractor_info(&name, f))
+        .map(|mut f| {
+            f.parenthesized_attrs = parenthesized_attrs && f.name == "attrs";
+            f
+        })
         .collect();
+    let has_attrs = fields
+        .iter()
+        .any(|f| f.name == "attrs" && !f.parenthesized_attrs);
     ExtractorNodeInfo {
         name,
         snake_case_name: to_lower_snake_case(&node.name),

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}}
@@ -33,6 +33,18 @@ impl Translator<'_> {
         if self.should_be_excluded(node) { return None; }
         {{/has_attrs}}
         {{#fields}}
+        {{#attributes}}
+        {{#parenthesized_attrs}}
+        let attrs = self.take_parenthesized_expr_attrs(node.syntax());
+        {{/parenthesized_attrs}}
+        {{^parenthesized_attrs}}
+        let mut attrs = self.take_parenthesized_expr_attrs(node.syntax());
+        attrs.extend(node.{{method}}().filter_map(|x| self.emit_{{snake_case_ty}}(&x)));
+        {{/parenthesized_attrs}}
+        {{/attributes}}
+        {{/fields}}
+        {{#fields}}
+        {{^attributes}}
         let {{name}} =
             {{#predicate}}
             node.{{method}}().is_some()
@@ -50,11 +62,17 @@ impl Translator<'_> {
             if self.should_skip_bodies() { None } else { node.{{method}}().and_then(|x| self.emit_{{snake_case_ty}}(&x)) }
             {{/body}}
             ;
+        {{/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

@@ -20,6 +20,7 @@ use ra_ap_syntax::{
 use ra_ap_syntax_bridge::{
     DocCommentDesugarMode, syntax_node_to_token_tree, token_tree_to_syntax_node,
 };
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 impl Emission<ast::Item> for Translator<'_> {
@@ -132,6 +133,7 @@ pub struct Translator<'db> {
     pub semantics: Option<&'db Semantics<'db, RootDatabase>>,
     source_kind: SourceKind,
     pub(crate) macro_context_depth: usize,
+    parenthesized_expr_attrs: HashMap<SyntaxNode, 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 +164,7 @@ impl<'db> Translator<'db> {
             semantics: semantic_info.map(|i| i.semantics),
             source_kind,
             macro_context_depth: 0,
+            parenthesized_expr_attrs: HashMap::new(),
             diagnostic_count: 0,
             builtin_derive_span_map: None,
         }
@@ -523,6 +526,55 @@ 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 mut attrs = self.take_parenthesized_expr_attrs(node.syntax());
+        attrs.extend(
+            node.attrs_with_doc()
+                .filter_map(|attr| self.emit_any_attr(&attr)),
+        );
+        let result = node.expr().and_then(|expr| {
+            let syntax = expr.syntax().clone();
+            self.parenthesized_expr_attrs
+                .entry(syntax.clone())
+                .or_default()
+                .extend(attrs);
+            let result = self.emit_expr(&expr);
+            self.parenthesized_expr_attrs.remove(&syntax);
+            result
+        });
+        if let Some(label) = result {
+            self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
+        }
+        result
+    }
+
+    pub(crate) fn emit_parenthesized_pat(
+        &mut self,
+        node: &ast::ParenPat,
+    ) -> Option<Label<generated::Pat>> {
+        let result = node.pat().and_then(|pat| self.emit_pat(&pat));
+        if let Some(label) = result {
+            self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
+        }
+        result
+    }
+
+    pub(crate) fn take_parenthesized_expr_attrs(
+        &mut self,
+        node: &SyntaxNode,
+    ) -> Vec<Label<generated::AnyAttr>> {
+        self.parenthesized_expr_attrs
+            .remove(node)
+            .unwrap_or_default()
+    }
+
     pub(crate) fn should_skip_bodies(&self) -> bool {
         self.source_kind == SourceKind::Library
     }