Rust: fix duplicate asm! expressions

Author: redsun82

rust/ast-generator/src/main.rs

@@ -82,6 +82,7 @@ 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
 }
 
 fn should_node_be_skipped_in_extractor(name: &str) -> bool {

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

@@ -834,6 +834,38 @@ impl<'a> Translator<'a> {
         }
     }
 
+    pub(crate) fn emit_macro_stmts(
+        &mut self,
+        node: &ast::MacroStmts,
+    ) -> Option<Label<generated::MacroBlockExpr>> {
+        // not generated to work around a bug in rust-analyzer AST generation machinery.
+        // Because an Expr can also be a Stmt (AsmExpr: Expr and AsmExpr: Item: Stmt)
+        // then such an element will be returned by both `expr()` and `statements()`
+        let mut statements = node.statements().collect::<Vec<_>>();
+        let tail_expr = node.expr();
+        if tail_expr
+            .as_ref()
+            .is_some_and(|e| statements.last().is_some_and(|s| s.syntax() == e.syntax()))
+        {
+            // if the expression matched as both the tail_expr and the last of the statements,
+            // only take it as tail_expr
+            statements.pop();
+        }
+        let tail_expr = tail_expr.and_then(|e| self.emit_expr(&e));
+        let statements = statements
+            .iter()
+            .filter_map(|x| self.emit_stmt(x))
+            .collect();
+        let label = self.trap.emit(generated::MacroBlockExpr {
+            id: TrapId::Star,
+            tail_expr,
+            statements,
+        });
+        self.emit_location(label, node);
+        self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());
+        Some(label)
+    }
+
     fn is_attribute_macro_target(&self, node: &ast::Item) -> bool {
         // rust-analyzer considers as an `attr_macro_call` also a plain macro call, but we want to
         // process that differently (in `extract_macro_call_expanded`)