From 7e917c9c35ea13906f452f1f009509bd5d5a6f24 Mon Sep 17 00:00:00 2001 From: Paolo Tranquilli Date: Thu, 22 May 2025 14:44:42 +0200 Subject: [PATCH 1/3] Rust: move body skipping logic to code generation --- rust/ast-generator/src/main.rs | 284 ++++------ .../templates/extractor.mustache | 32 +- rust/extractor/src/translate/base.rs | 43 +- rust/extractor/src/translate/generated.rs | 486 +----------------- 4 files changed, 145 insertions(+), 700 deletions(-) diff --git a/rust/ast-generator/src/main.rs b/rust/ast-generator/src/main.rs index 83999711161d..c41a8c4e4b32 100644 --- a/rust/ast-generator/src/main.rs +++ b/rust/ast-generator/src/main.rs @@ -114,7 +114,9 @@ fn node_src_to_schema_class( let (ty, child) = match &f.ty { FieldType::String => ("optional[string]".to_string(), false), FieldType::Predicate => ("predicate".to_string(), false), - FieldType::Optional(ty) => (format!("optional[\"{}\"]", class_name(ty)), true), + FieldType::Optional(ty) | FieldType::Body(ty) => { + (format!("optional[\"{}\"]", class_name(ty)), true) + } FieldType::List(ty) => (format!("list[\"{}\"]", class_name(ty)), true), }; SchemaField { @@ -169,6 +171,7 @@ enum FieldType { String, Predicate, Optional(String), + Body(String), List(String), } @@ -177,158 +180,93 @@ struct FieldInfo { ty: FieldType, } +impl FieldInfo { + pub fn optional(name: &str, ty: &str) -> FieldInfo { + FieldInfo { + name: name.to_string(), + ty: FieldType::Optional(ty.to_string()), + } + } + + pub fn body(name: &str, ty: &str) -> FieldInfo { + FieldInfo { + name: name.to_string(), + ty: FieldType::Body(ty.to_string()), + } + } + + pub fn string(name: &str) -> FieldInfo { + FieldInfo { + name: name.to_string(), + ty: FieldType::String, + } + } + + pub fn predicate(name: &str) -> FieldInfo { + FieldInfo { + name: name.to_string(), + ty: FieldType::Predicate, + } + } + + pub fn list(name: &str, ty: &str) -> FieldInfo { + FieldInfo { + name: name.to_string(), + ty: FieldType::List(ty.to_string()), + } + } +} + fn get_additional_fields(node: &AstNodeSrc) -> Vec { match node.name.as_str() { - "Name" | "NameRef" | "Lifetime" => vec![FieldInfo { - name: "text".to_string(), - ty: FieldType::String, - }], - "Abi" => vec![FieldInfo { - name: "abi_string".to_string(), - ty: FieldType::String, - }], - "Literal" => vec![FieldInfo { - name: "text_value".to_string(), - ty: FieldType::String, - }], - "PrefixExpr" => vec![FieldInfo { - name: "operator_name".to_string(), - ty: FieldType::String, - }], + "Name" | "NameRef" | "Lifetime" => vec![FieldInfo::string("text")], + "Abi" => vec![FieldInfo::string("abi_string")], + "Literal" => vec![FieldInfo::string("text_value")], + "PrefixExpr" => vec![FieldInfo::string("operator_name")], "BinExpr" => vec![ - FieldInfo { - name: "lhs".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }, - FieldInfo { - name: "rhs".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }, - FieldInfo { - name: "operator_name".to_string(), - ty: FieldType::String, - }, + FieldInfo::optional("lhs", "Expr"), + FieldInfo::optional("rhs", "Expr"), + FieldInfo::string("operator_name"), ], "IfExpr" => vec![ - FieldInfo { - name: "then_branch".to_string(), - ty: FieldType::Optional("BlockExpr".to_string()), - }, - FieldInfo { - name: "else_branch".to_string(), - ty: FieldType::Optional("ElseBranch".to_string()), - }, - FieldInfo { - name: "condition".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }, + FieldInfo::optional("then_branch", "BlockExpr"), + FieldInfo::optional("else_branch", "ElseBranch"), + FieldInfo::optional("condition", "Expr"), ], "RangeExpr" => vec![ - FieldInfo { - name: "start".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }, - FieldInfo { - name: "end".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }, - FieldInfo { - name: "operator_name".to_string(), - ty: FieldType::String, - }, + FieldInfo::optional("start", "Expr"), + FieldInfo::optional("end", "Expr"), + FieldInfo::string("operator_name"), ], "RangePat" => vec![ - FieldInfo { - name: "start".to_string(), - ty: FieldType::Optional("Pat".to_string()), - }, - FieldInfo { - name: "end".to_string(), - ty: FieldType::Optional("Pat".to_string()), - }, - FieldInfo { - name: "operator_name".to_string(), - ty: FieldType::String, - }, + FieldInfo::optional("start", "Pat"), + FieldInfo::optional("end", "Pat"), + FieldInfo::string("operator_name"), ], "IndexExpr" => vec![ - FieldInfo { - name: "index".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }, - FieldInfo { - name: "base".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }, + FieldInfo::optional("index", "Expr"), + FieldInfo::optional("base", "Expr"), ], "Impl" => vec![ - FieldInfo { - name: "trait_".to_string(), - ty: FieldType::Optional("Type".to_string()), - }, - FieldInfo { - name: "self_ty".to_string(), - ty: FieldType::Optional("Type".to_string()), - }, + FieldInfo::optional("trait_", "Type"), + FieldInfo::optional("self_ty", "Type"), ], - "ForExpr" => vec![FieldInfo { - name: "iterable".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }], - "WhileExpr" => vec![FieldInfo { - name: "condition".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }], - "MatchGuard" => vec![FieldInfo { - name: "condition".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }], + "ForExpr" => vec![FieldInfo::optional("iterable", "Expr")], + "WhileExpr" => vec![FieldInfo::optional("condition", "Expr")], + "MatchGuard" => vec![FieldInfo::optional("condition", "Expr")], "MacroDef" => vec![ - FieldInfo { - name: "args".to_string(), - ty: FieldType::Optional("TokenTree".to_string()), - }, - FieldInfo { - name: "body".to_string(), - ty: FieldType::Optional("TokenTree".to_string()), - }, + FieldInfo::optional("args", "TokenTree"), + FieldInfo::optional("body", "TokenTree"), ], - "FormatArgsExpr" => vec![FieldInfo { - name: "args".to_string(), - ty: FieldType::List("FormatArgsArg".to_string()), - }], - "ArgList" => vec![FieldInfo { - name: "args".to_string(), - ty: FieldType::List("Expr".to_string()), - }], - "Fn" => vec![FieldInfo { - name: "body".to_string(), - ty: FieldType::Optional("BlockExpr".to_string()), - }], - "Const" => vec![FieldInfo { - name: "body".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }], - "Static" => vec![FieldInfo { - name: "body".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }], - "ClosureExpr" => vec![FieldInfo { - name: "body".to_string(), - ty: FieldType::Optional("Expr".to_string()), - }], - "ArrayExpr" => vec![FieldInfo { - name: "is_semicolon".to_string(), - ty: FieldType::Predicate, - }], - "SelfParam" => vec![FieldInfo { - name: "is_amp".to_string(), - ty: FieldType::Predicate, - }], - "UseTree" => vec![FieldInfo { - name: "is_star".to_string(), - ty: FieldType::Predicate, - }], + "FormatArgsExpr" => vec![FieldInfo::list("args", "FormatArgsArg")], + "ArgList" => vec![FieldInfo::list("args", "Expr")], + "Fn" => vec![FieldInfo::body("body", "BlockExpr")], + "Const" => vec![FieldInfo::body("body", "Expr")], + "Static" => vec![FieldInfo::body("body", "Expr")], + "ClosureExpr" => vec![FieldInfo::optional("body", "Expr")], + "ArrayExpr" => vec![FieldInfo::predicate("is_semicolon")], + "SelfParam" => vec![FieldInfo::predicate("is_amp")], + "UseTree" => vec![FieldInfo::predicate("is_star")], _ => vec![], } } @@ -356,6 +294,10 @@ fn get_fields(node: &AstNodeSrc) -> Vec { ("ArrayExpr", "expr") // The ArrayExpr type also has an 'exprs' field | ("PathSegment", "ty" | "path_type") // these are broken, handling them manually => continue, + ("Param", "pat") => { + result.push(FieldInfo::body("pat", "Pat")); + continue; + }, _ => {} } let ty = match field { @@ -374,54 +316,26 @@ fn get_fields(node: &AstNodeSrc) -> Vec { } for trait_ in &node.traits { match trait_.as_str() { - "HasAttrs" => result.push(FieldInfo { - name: "attrs".to_owned(), - ty: FieldType::List("Attr".to_owned()), - }), - "HasName" => result.push(FieldInfo { - name: "name".to_owned(), - ty: FieldType::Optional("Name".to_owned()), - }), - "HasVisibility" => result.push(FieldInfo { - name: "visibility".to_owned(), - ty: FieldType::Optional("Visibility".to_owned()), - }), + "HasAttrs" => result.push(FieldInfo::list("attrs", "Attr")), + "HasName" => result.push(FieldInfo::optional("name", "Name")), + "HasVisibility" => result.push(FieldInfo::optional("visibility", "Visibility")), "HasGenericParams" => { - result.push(FieldInfo { - name: "generic_param_list".to_owned(), - ty: FieldType::Optional("GenericParamList".to_owned()), - }); - result.push(FieldInfo { - name: "where_clause".to_owned(), - ty: FieldType::Optional("WhereClause".to_owned()), - }) + result.push(FieldInfo::optional( + "generic_param_list", + "GenericParamList", + )); + result.push(FieldInfo::optional("where_clause", "WhereClause")) + } + "HasGenericArgs" => { + result.push(FieldInfo::optional("generic_arg_list", "GenericArgList")) } - "HasGenericArgs" => result.push(FieldInfo { - name: "generic_arg_list".to_owned(), - ty: FieldType::Optional("GenericArgList".to_owned()), - }), - "HasTypeBounds" => result.push(FieldInfo { - name: "type_bound_list".to_owned(), - ty: FieldType::Optional("TypeBoundList".to_owned()), - }), - "HasModuleItem" => result.push(FieldInfo { - name: "items".to_owned(), - ty: FieldType::List("Item".to_owned()), - }), + "HasTypeBounds" => result.push(FieldInfo::optional("type_bound_list", "TypeBoundList")), + "HasModuleItem" => result.push(FieldInfo::list("items", "Item")), "HasLoopBody" => { - result.push(FieldInfo { - name: "label".to_owned(), - ty: FieldType::Optional("Label".to_owned()), - }); - result.push(FieldInfo { - name: "loop_body".to_owned(), - ty: FieldType::Optional("BlockExpr".to_owned()), - }) + result.push(FieldInfo::optional("label", "Label")); + result.push(FieldInfo::optional("loop_body", "BlockExpr")) } - "HasArgList" => result.push(FieldInfo { - name: "arg_list".to_owned(), - ty: FieldType::Optional("ArgList".to_owned()), - }), + "HasArgList" => result.push(FieldInfo::optional("arg_list", "ArgList")), "HasDocComments" => {} _ => panic!("Unknown trait {}", trait_), @@ -455,6 +369,7 @@ struct ExtractorNodeFieldInfo { predicate: bool, optional: bool, list: bool, + body: bool, } #[derive(Serialize)] @@ -518,6 +433,13 @@ fn field_info_to_extractor_info(name: &str, field: &FieldInfo) -> ExtractorNodeF optional: true, ..Default::default() }, + FieldType::Body(ty) => ExtractorNodeFieldInfo { + name, + method: field.name.clone(), + snake_case_ty: to_lower_snake_case(ty), + body: true, + ..Default::default() + }, FieldType::List(ty) => ExtractorNodeFieldInfo { name, method: field.name.clone(), diff --git a/rust/ast-generator/templates/extractor.mustache b/rust/ast-generator/templates/extractor.mustache index 0ce5b863f267..cd3f0a2b8839 100644 --- a/rust/ast-generator/templates/extractor.mustache +++ b/rust/ast-generator/templates/extractor.mustache @@ -34,23 +34,27 @@ impl Translator<'_> { {{#nodes}} pub(crate) fn emit_{{snake_case_name}}(&mut self, node: &ast::{{ast_name}}) -> Option> { - if self.should_be_excluded(node) { return None; } {{#has_attrs}} - if self.should_be_excluded_attrs(node) { return None; } + if self.should_be_excluded(node) { return None; } {{/has_attrs}} {{#fields}} - {{#predicate}} - let {{name}} = node.{{method}}().is_some(); - {{/predicate}} - {{#string}} - let {{name}} = node.try_get_text(); - {{/string}} - {{#list}} - let {{name}} = node.{{method}}().filter_map(|x| self.emit_{{snake_case_ty}}(&x)).collect(); - {{/list}} - {{#optional}} - let {{name}} = node.{{method}}().and_then(|x| self.emit_{{snake_case_ty}}(&x)); - {{/optional}} + let {{name}} = + {{#predicate}} + node.{{method}}().is_some() + {{/predicate}} + {{#string}} + node.try_get_text() + {{/string}} + {{#list}} + node.{{method}}().filter_map(|x| self.emit_{{snake_case_ty}}(&x)).collect() + {{/list}} + {{#optional}} + node.{{method}}().and_then(|x| self.emit_{{snake_case_ty}}(&x)) + {{/optional}} + {{#body}} + if self.should_skip_bodies() { None } else { node.{{method}}().and_then(|x| self.emit_{{snake_case_ty}}(&x)) } + {{/body}} + ; {{/fields}} let label = self.trap.emit(generated::{{name}} { id: TrapId::Star, diff --git a/rust/extractor/src/translate/base.rs b/rust/extractor/src/translate/base.rs index e440e00cb25e..6a1fcb2ec10d 100644 --- a/rust/extractor/src/translate/base.rs +++ b/rust/extractor/src/translate/base.rs @@ -16,7 +16,7 @@ use ra_ap_ide_db::RootDatabase; use ra_ap_ide_db::line_index::{LineCol, LineIndex}; use ra_ap_parser::SyntaxKind; use ra_ap_span::TextSize; -use ra_ap_syntax::ast::{Const, Fn, HasName, Param, Static}; +use ra_ap_syntax::ast::HasName; use ra_ap_syntax::{ AstNode, NodeOrToken, SyntaxElementChildren, SyntaxError, SyntaxNode, SyntaxToken, TextRange, ast, @@ -627,7 +627,7 @@ impl<'a> Translator<'a> { })(); } - pub(crate) fn should_be_excluded_attrs(&self, item: &impl ast::HasAttrs) -> bool { + pub(crate) fn should_be_excluded(&self, item: &impl ast::HasAttrs) -> bool { self.semantics.is_some_and(|sema| { item.attrs().any(|attr| { attr.as_simple_call().is_some_and(|(name, tokens)| { @@ -637,43 +637,8 @@ impl<'a> Translator<'a> { }) } - pub(crate) fn should_be_excluded(&self, item: &impl ast::AstNode) -> bool { - if self.source_kind == SourceKind::Library { - let syntax = item.syntax(); - if syntax - .parent() - .and_then(Fn::cast) - .and_then(|x| x.body()) - .is_some_and(|body| body.syntax() == syntax) - { - return true; - } - if syntax - .parent() - .and_then(Const::cast) - .and_then(|x| x.body()) - .is_some_and(|body| body.syntax() == syntax) - { - return true; - } - if syntax - .parent() - .and_then(Static::cast) - .and_then(|x| x.body()) - .is_some_and(|body| body.syntax() == syntax) - { - return true; - } - if syntax - .parent() - .and_then(Param::cast) - .and_then(|x| x.pat()) - .is_some_and(|pat| pat.syntax() == syntax) - { - return true; - } - } - false + pub(crate) fn should_skip_bodies(&self) -> bool { + self.source_kind == SourceKind::Library } pub(crate) fn extract_types_from_path_segment( diff --git a/rust/extractor/src/translate/generated.rs b/rust/extractor/src/translate/generated.rs index 84159f970c9a..6f386df6ed1f 100644 --- a/rust/extractor/src/translate/generated.rs +++ b/rust/extractor/src/translate/generated.rs @@ -242,9 +242,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_abi(&mut self, node: &ast::Abi) -> Option> { - if self.should_be_excluded(node) { - return None; - } let abi_string = node.try_get_text(); let label = self.trap.emit(generated::Abi { id: TrapId::Star, @@ -259,9 +256,6 @@ impl Translator<'_> { &mut self, node: &ast::ArgList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let args = node.args().filter_map(|x| self.emit_expr(&x)).collect(); let label = self.trap.emit(generated::ArgList { id: TrapId::Star, @@ -279,9 +273,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let exprs = node.exprs().filter_map(|x| self.emit_expr(&x)).collect(); let is_semicolon = node.semicolon_token().is_some(); @@ -300,9 +291,6 @@ impl Translator<'_> { &mut self, node: &ast::ArrayType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let const_arg = node.const_arg().and_then(|x| self.emit_const_arg(&x)); let element_type_repr = node.ty().and_then(|x| self.emit_type(&x)); let label = self.trap.emit(generated::ArrayTypeRepr { @@ -319,9 +307,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmClobberAbi, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::AsmClobberAbi { id: TrapId::Star }); @@ -334,9 +319,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmConst, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let expr = node.expr().and_then(|x| self.emit_expr(&x)); let is_const = node.const_token().is_some(); let label = self.trap.emit(generated::AsmConst { @@ -353,9 +335,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmDirSpec, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let label = self.trap.emit(generated::AsmDirSpec { id: TrapId::Star }); self.emit_location(label, node); emit_detached!(AsmDirSpec, self, node, label); @@ -369,9 +348,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let asm_pieces = node .asm_pieces() .filter_map(|x| self.emit_asm_piece(&x)) @@ -393,9 +369,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmLabel, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x)); let label = self.trap.emit(generated::AsmLabel { id: TrapId::Star, @@ -410,9 +383,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmOperandExpr, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let in_expr = node.in_expr().and_then(|x| self.emit_expr(&x)); let out_expr = node.out_expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::AsmOperandExpr { @@ -429,9 +399,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmOperandNamed, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let asm_operand = node.asm_operand().and_then(|x| self.emit_asm_operand(&x)); let name = node.name().and_then(|x| self.emit_name(&x)); let label = self.trap.emit(generated::AsmOperandNamed { @@ -448,9 +415,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmOption, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let is_raw = node.raw_token().is_some(); let label = self.trap.emit(generated::AsmOption { id: TrapId::Star, @@ -465,9 +429,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmOptions, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let asm_options = node .asm_options() .filter_map(|x| self.emit_asm_option(&x)) @@ -485,9 +446,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmRegOperand, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let asm_dir_spec = node.asm_dir_spec().and_then(|x| self.emit_asm_dir_spec(&x)); let asm_operand_expr = node .asm_operand_expr() @@ -508,9 +466,6 @@ impl Translator<'_> { &mut self, node: &ast::AsmRegSpec, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x)); let label = self.trap.emit(generated::AsmRegSpec { id: TrapId::Star, @@ -522,9 +477,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_asm_sym(&mut self, node: &ast::AsmSym) -> Option> { - if self.should_be_excluded(node) { - return None; - } let path = node.path().and_then(|x| self.emit_path(&x)); let label = self.trap.emit(generated::AsmSym { id: TrapId::Star, @@ -542,9 +494,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let assoc_items = node .assoc_items() .filter_map(|x| self.emit_assoc_item(&x)) @@ -564,9 +513,6 @@ impl Translator<'_> { &mut self, node: &ast::AssocTypeArg, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let const_arg = node.const_arg().and_then(|x| self.emit_const_arg(&x)); let generic_arg_list = node .generic_arg_list() @@ -598,9 +544,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_attr(&mut self, node: &ast::Attr) -> Option> { - if self.should_be_excluded(node) { - return None; - } let meta = node.meta().and_then(|x| self.emit_meta(&x)); let label = self.trap.emit(generated::Attr { id: TrapId::Star, @@ -618,9 +561,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::AwaitExpr { @@ -640,9 +580,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::BecomeExpr { @@ -662,9 +599,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let lhs = node.lhs().and_then(|x| self.emit_expr(&x)); let operator_name = node.try_get_text(); @@ -688,9 +622,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let is_async = node.async_token().is_some(); let is_const = node.const_token().is_some(); @@ -718,9 +649,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_box_pat(&mut self, node: &ast::BoxPat) -> Option> { - if self.should_be_excluded(node) { - return None; - } let pat = node.pat().and_then(|x| self.emit_pat(&x)); let label = self.trap.emit(generated::BoxPat { id: TrapId::Star, @@ -738,9 +666,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x)); @@ -762,9 +687,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let arg_list = node.arg_list().and_then(|x| self.emit_arg_list(&x)); let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let function = node.expr().and_then(|x| self.emit_expr(&x)); @@ -786,9 +708,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let type_repr = node.ty().and_then(|x| self.emit_type(&x)); @@ -807,9 +726,6 @@ impl Translator<'_> { &mut self, node: &ast::ClosureBinder, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let generic_param_list = node .generic_param_list() .and_then(|x| self.emit_generic_param_list(&x)); @@ -829,9 +745,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let body = node.body().and_then(|x| self.emit_expr(&x)); let closure_binder = node @@ -866,11 +779,12 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); - let body = node.body().and_then(|x| self.emit_expr(&x)); + let body = if self.should_skip_bodies() { + None + } else { + node.body().and_then(|x| self.emit_expr(&x)) + }; let is_const = node.const_token().is_some(); let is_default = node.default_token().is_some(); let name = node.name().and_then(|x| self.emit_name(&x)); @@ -895,9 +809,6 @@ impl Translator<'_> { &mut self, node: &ast::ConstArg, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::ConstArg { id: TrapId::Star, @@ -912,9 +823,6 @@ impl Translator<'_> { &mut self, node: &ast::ConstBlockPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x)); let is_const = node.const_token().is_some(); let label = self.trap.emit(generated::ConstBlockPat { @@ -934,9 +842,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let default_val = node.default_val().and_then(|x| self.emit_const_arg(&x)); let is_const = node.const_token().is_some(); @@ -962,9 +867,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x)); let label = self.trap.emit(generated::ContinueExpr { @@ -981,9 +883,6 @@ impl Translator<'_> { &mut self, node: &ast::DynTraitType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let type_bound_list = node .type_bound_list() .and_then(|x| self.emit_type_bound_list(&x)); @@ -1000,9 +899,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let generic_param_list = node .generic_param_list() @@ -1029,9 +925,6 @@ impl Translator<'_> { &mut self, node: &ast::ExprStmt, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::ExprStmt { id: TrapId::Star, @@ -1049,9 +942,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let abi = node.abi().and_then(|x| self.emit_abi(&x)); let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let extern_item_list = node @@ -1077,9 +967,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x)); let rename = node.rename().and_then(|x| self.emit_rename(&x)); @@ -1103,9 +990,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let extern_items = node .extern_items() @@ -1128,9 +1012,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let container = node.expr().and_then(|x| self.emit_expr(&x)); let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x)); @@ -1149,12 +1030,13 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let abi = node.abi().and_then(|x| self.emit_abi(&x)); let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); - let body = node.body().and_then(|x| self.emit_block_expr(&x)); + let body = if self.should_skip_bodies() { + None + } else { + node.body().and_then(|x| self.emit_block_expr(&x)) + }; let generic_param_list = node .generic_param_list() .and_then(|x| self.emit_generic_param_list(&x)); @@ -1194,9 +1076,6 @@ impl Translator<'_> { &mut self, node: &ast::FnPtrType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let abi = node.abi().and_then(|x| self.emit_abi(&x)); let is_async = node.async_token().is_some(); let is_const = node.const_token().is_some(); @@ -1224,9 +1103,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let iterable = node.iterable().and_then(|x| self.emit_expr(&x)); let label = node.label().and_then(|x| self.emit_label(&x)); @@ -1249,9 +1125,6 @@ impl Translator<'_> { &mut self, node: &ast::ForType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let generic_param_list = node .generic_param_list() .and_then(|x| self.emit_generic_param_list(&x)); @@ -1270,9 +1143,6 @@ impl Translator<'_> { &mut self, node: &ast::FormatArgsArg, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let expr = node.expr().and_then(|x| self.emit_expr(&x)); let name = node.name().and_then(|x| self.emit_name(&x)); let label = self.trap.emit(generated::FormatArgsArg { @@ -1292,9 +1162,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let args = node .args() .filter_map(|x| self.emit_format_args_arg(&x)) @@ -1316,9 +1183,6 @@ impl Translator<'_> { &mut self, node: &ast::GenericArgList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let generic_args = node .generic_args() .filter_map(|x| self.emit_generic_arg(&x)) @@ -1336,9 +1200,6 @@ impl Translator<'_> { &mut self, node: &ast::GenericParamList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let generic_params = node .generic_params() .filter_map(|x| self.emit_generic_param(&x)) @@ -1359,9 +1220,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let is_mut = node.mut_token().is_some(); let is_ref = node.ref_token().is_some(); @@ -1384,9 +1242,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let condition = node.condition().and_then(|x| self.emit_expr(&x)); let else_ = node.else_branch().and_then(|x| self.emit_else_branch(&x)); @@ -1407,9 +1262,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let assoc_item_list = node .assoc_item_list() .and_then(|x| self.emit_assoc_item_list(&x)); @@ -1446,9 +1298,6 @@ impl Translator<'_> { &mut self, node: &ast::ImplTraitType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let type_bound_list = node .type_bound_list() .and_then(|x| self.emit_type_bound_list(&x)); @@ -1468,9 +1317,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let base = node.base().and_then(|x| self.emit_expr(&x)); let index = node.index().and_then(|x| self.emit_expr(&x)); @@ -1489,9 +1335,6 @@ impl Translator<'_> { &mut self, node: &ast::InferType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::InferTypeRepr { id: TrapId::Star }); @@ -1507,9 +1350,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let items = node.items().filter_map(|x| self.emit_item(&x)).collect(); let label = self.trap.emit(generated::ItemList { @@ -1523,9 +1363,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_label(&mut self, node: &ast::Label) -> Option> { - if self.should_be_excluded(node) { - return None; - } let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x)); let label = self.trap.emit(generated::Label { id: TrapId::Star, @@ -1540,9 +1377,6 @@ impl Translator<'_> { &mut self, node: &ast::LetElse, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x)); let label = self.trap.emit(generated::LetElse { id: TrapId::Star, @@ -1560,9 +1394,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let scrutinee = node.expr().and_then(|x| self.emit_expr(&x)); let pat = node.pat().and_then(|x| self.emit_pat(&x)); @@ -1584,9 +1415,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let initializer = node.initializer().and_then(|x| self.emit_expr(&x)); let let_else = node.let_else().and_then(|x| self.emit_let_else(&x)); @@ -1609,9 +1437,6 @@ impl Translator<'_> { &mut self, node: &ast::Lifetime, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let text = node.try_get_text(); let label = self.trap.emit(generated::Lifetime { id: TrapId::Star, @@ -1626,9 +1451,6 @@ impl Translator<'_> { &mut self, node: &ast::LifetimeArg, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x)); let label = self.trap.emit(generated::LifetimeArg { id: TrapId::Star, @@ -1646,9 +1468,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x)); let type_bound_list = node @@ -1672,9 +1491,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let text_value = node.try_get_text(); let label = self.trap.emit(generated::LiteralExpr { @@ -1691,9 +1507,6 @@ impl Translator<'_> { &mut self, node: &ast::LiteralPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let literal = node.literal().and_then(|x| self.emit_literal(&x)); let label = self.trap.emit(generated::LiteralPat { id: TrapId::Star, @@ -1711,9 +1524,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let label = node.label().and_then(|x| self.emit_label(&x)); let loop_body = node.loop_body().and_then(|x| self.emit_block_expr(&x)); @@ -1735,9 +1545,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let path = node.path().and_then(|x| self.emit_path(&x)); let token_tree = node.token_tree().and_then(|x| self.emit_token_tree(&x)); @@ -1759,9 +1566,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let args = node.args().and_then(|x| self.emit_token_tree(&x)); let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let body = node.body().and_then(|x| self.emit_token_tree(&x)); @@ -1784,9 +1588,6 @@ impl Translator<'_> { &mut self, node: &ast::MacroExpr, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let macro_call = node.macro_call().and_then(|x| self.emit_macro_call(&x)); let label = self.trap.emit(generated::MacroExpr { id: TrapId::Star, @@ -1801,9 +1602,6 @@ impl Translator<'_> { &mut self, node: &ast::MacroItems, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let items = node.items().filter_map(|x| self.emit_item(&x)).collect(); let label = self.trap.emit(generated::MacroItems { id: TrapId::Star, @@ -1818,9 +1616,6 @@ impl Translator<'_> { &mut self, node: &ast::MacroPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let macro_call = node.macro_call().and_then(|x| self.emit_macro_call(&x)); let label = self.trap.emit(generated::MacroPat { id: TrapId::Star, @@ -1838,9 +1633,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let name = node.name().and_then(|x| self.emit_name(&x)); let token_tree = node.token_tree().and_then(|x| self.emit_token_tree(&x)); @@ -1861,9 +1653,6 @@ impl Translator<'_> { &mut self, node: &ast::MacroStmts, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let tail_expr = node.expr().and_then(|x| self.emit_expr(&x)); let statements = node .statements() @@ -1883,9 +1672,6 @@ impl Translator<'_> { &mut self, node: &ast::MacroType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let macro_call = node.macro_call().and_then(|x| self.emit_macro_call(&x)); let label = self.trap.emit(generated::MacroTypeRepr { id: TrapId::Star, @@ -1903,9 +1689,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let guard = node.guard().and_then(|x| self.emit_match_guard(&x)); @@ -1929,9 +1712,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let arms = node .arms() .filter_map(|x| self.emit_match_arm(&x)) @@ -1954,9 +1734,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let scrutinee = node.expr().and_then(|x| self.emit_expr(&x)); let match_arm_list = node @@ -1977,9 +1754,6 @@ impl Translator<'_> { &mut self, node: &ast::MatchGuard, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let condition = node.condition().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::MatchGuard { id: TrapId::Star, @@ -1991,9 +1765,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_meta(&mut self, node: &ast::Meta) -> Option> { - if self.should_be_excluded(node) { - return None; - } let expr = node.expr().and_then(|x| self.emit_expr(&x)); let is_unsafe = node.unsafe_token().is_some(); let path = node.path().and_then(|x| self.emit_path(&x)); @@ -2017,9 +1788,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let arg_list = node.arg_list().and_then(|x| self.emit_arg_list(&x)); let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let generic_arg_list = node @@ -2044,9 +1812,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let item_list = node.item_list().and_then(|x| self.emit_item_list(&x)); let name = node.name().and_then(|x| self.emit_name(&x)); @@ -2064,9 +1829,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_name(&mut self, node: &ast::Name) -> Option> { - if self.should_be_excluded(node) { - return None; - } let text = node.try_get_text(); let label = self.trap.emit(generated::Name { id: TrapId::Star, @@ -2081,9 +1843,6 @@ impl Translator<'_> { &mut self, node: &ast::NameRef, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let text = node.try_get_text(); let label = self.trap.emit(generated::NameRef { id: TrapId::Star, @@ -2098,9 +1857,6 @@ impl Translator<'_> { &mut self, node: &ast::NeverType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::NeverTypeRepr { id: TrapId::Star }); @@ -2116,9 +1872,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let fields = node .fields() @@ -2137,9 +1890,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_or_pat(&mut self, node: &ast::OrPat) -> Option> { - if self.should_be_excluded(node) { - return None; - } let pats = node.pats().filter_map(|x| self.emit_pat(&x)).collect(); let label = self.trap.emit(generated::OrPat { id: TrapId::Star, @@ -2154,11 +1904,12 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); - let pat = node.pat().and_then(|x| self.emit_pat(&x)); + let pat = if self.should_skip_bodies() { + None + } else { + node.pat().and_then(|x| self.emit_pat(&x)) + }; let type_repr = node.ty().and_then(|x| self.emit_type(&x)); let label = self.trap.emit(generated::Param { id: TrapId::Star, @@ -2175,9 +1926,6 @@ impl Translator<'_> { &mut self, node: &ast::ParamList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let params = node.params().filter_map(|x| self.emit_param(&x)).collect(); let self_param = node.self_param().and_then(|x| self.emit_self_param(&x)); let label = self.trap.emit(generated::ParamList { @@ -2197,9 +1945,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::ParenExpr { @@ -2216,9 +1961,6 @@ impl Translator<'_> { &mut self, node: &ast::ParenPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let pat = node.pat().and_then(|x| self.emit_pat(&x)); let label = self.trap.emit(generated::ParenPat { id: TrapId::Star, @@ -2233,9 +1975,6 @@ impl Translator<'_> { &mut self, node: &ast::ParenType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let type_repr = node.ty().and_then(|x| self.emit_type(&x)); let label = self.trap.emit(generated::ParenTypeRepr { id: TrapId::Star, @@ -2250,9 +1989,6 @@ impl Translator<'_> { &mut self, node: &ast::ParenthesizedArgList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let type_args = node .type_args() .filter_map(|x| self.emit_type_arg(&x)) @@ -2267,9 +2003,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_path(&mut self, node: &ast::Path) -> Option> { - if self.should_be_excluded(node) { - return None; - } let qualifier = node.qualifier().and_then(|x| self.emit_path(&x)); let segment = node.segment().and_then(|x| self.emit_path_segment(&x)); let label = self.trap.emit(generated::Path { @@ -2289,9 +2022,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let path = node.path().and_then(|x| self.emit_path(&x)); let label = self.trap.emit(generated::PathExpr { @@ -2308,9 +2038,6 @@ impl Translator<'_> { &mut self, node: &ast::PathPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let path = node.path().and_then(|x| self.emit_path(&x)); let label = self.trap.emit(generated::PathPat { id: TrapId::Star, @@ -2325,9 +2052,6 @@ impl Translator<'_> { &mut self, node: &ast::PathSegment, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let generic_arg_list = node .generic_arg_list() .and_then(|x| self.emit_generic_arg_list(&x)); @@ -2356,9 +2080,6 @@ impl Translator<'_> { &mut self, node: &ast::PathType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let path = node.path().and_then(|x| self.emit_path(&x)); let label = self.trap.emit(generated::PathTypeRepr { id: TrapId::Star, @@ -2376,9 +2097,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let operator_name = node.try_get_text(); @@ -2397,9 +2115,6 @@ impl Translator<'_> { &mut self, node: &ast::PtrType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let is_const = node.const_token().is_some(); let is_mut = node.mut_token().is_some(); let type_repr = node.ty().and_then(|x| self.emit_type(&x)); @@ -2421,9 +2136,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let end = node.end().and_then(|x| self.emit_expr(&x)); let operator_name = node.try_get_text(); @@ -2444,9 +2156,6 @@ impl Translator<'_> { &mut self, node: &ast::RangePat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let end = node.end().and_then(|x| self.emit_pat(&x)); let operator_name = node.try_get_text(); let start = node.start().and_then(|x| self.emit_pat(&x)); @@ -2465,9 +2174,6 @@ impl Translator<'_> { &mut self, node: &ast::RecordExpr, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let path = node.path().and_then(|x| self.emit_path(&x)); let struct_expr_field_list = node .record_expr_field_list() @@ -2489,9 +2195,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x)); @@ -2513,9 +2216,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let fields = node .fields() @@ -2540,9 +2240,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let default = node.expr().and_then(|x| self.emit_expr(&x)); let is_unsafe = node.unsafe_token().is_some(); @@ -2567,9 +2264,6 @@ impl Translator<'_> { &mut self, node: &ast::RecordFieldList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let fields = node .fields() .filter_map(|x| self.emit_record_field(&x)) @@ -2587,9 +2281,6 @@ impl Translator<'_> { &mut self, node: &ast::RecordPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let path = node.path().and_then(|x| self.emit_path(&x)); let struct_pat_field_list = node .record_pat_field_list() @@ -2611,9 +2302,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x)); let pat = node.pat().and_then(|x| self.emit_pat(&x)); @@ -2632,9 +2320,6 @@ impl Translator<'_> { &mut self, node: &ast::RecordPatFieldList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let fields = node .fields() .filter_map(|x| self.emit_record_pat_field(&x)) @@ -2657,9 +2342,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let is_const = node.const_token().is_some(); @@ -2679,9 +2361,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_ref_pat(&mut self, node: &ast::RefPat) -> Option> { - if self.should_be_excluded(node) { - return None; - } let is_mut = node.mut_token().is_some(); let pat = node.pat().and_then(|x| self.emit_pat(&x)); let label = self.trap.emit(generated::RefPat { @@ -2698,9 +2377,6 @@ impl Translator<'_> { &mut self, node: &ast::RefType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let is_mut = node.mut_token().is_some(); let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x)); let type_repr = node.ty().and_then(|x| self.emit_type(&x)); @@ -2716,9 +2392,6 @@ impl Translator<'_> { Some(label) } pub(crate) fn emit_rename(&mut self, node: &ast::Rename) -> Option> { - if self.should_be_excluded(node) { - return None; - } let name = node.name().and_then(|x| self.emit_name(&x)); let label = self.trap.emit(generated::Rename { id: TrapId::Star, @@ -2736,9 +2409,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let label = self.trap.emit(generated::RestPat { id: TrapId::Star, @@ -2753,9 +2423,6 @@ impl Translator<'_> { &mut self, node: &ast::RetType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let type_repr = node.ty().and_then(|x| self.emit_type(&x)); let label = self.trap.emit(generated::RetTypeRepr { id: TrapId::Star, @@ -2773,9 +2440,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::ReturnExpr { @@ -2792,9 +2456,6 @@ impl Translator<'_> { &mut self, node: &ast::ReturnTypeSyntax, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::ReturnTypeSyntax { id: TrapId::Star }); @@ -2810,9 +2471,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let is_ref = node.amp_token().is_some(); let is_mut = node.mut_token().is_some(); @@ -2837,9 +2495,6 @@ impl Translator<'_> { &mut self, node: &ast::SlicePat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let pats = node.pats().filter_map(|x| self.emit_pat(&x)).collect(); let label = self.trap.emit(generated::SlicePat { id: TrapId::Star, @@ -2854,9 +2509,6 @@ impl Translator<'_> { &mut self, node: &ast::SliceType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let type_repr = node.ty().and_then(|x| self.emit_type(&x)); let label = self.trap.emit(generated::SliceTypeRepr { id: TrapId::Star, @@ -2874,9 +2526,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let items = node.items().filter_map(|x| self.emit_item(&x)).collect(); let label = self.trap.emit(generated::SourceFile { @@ -2893,11 +2542,12 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); - let body = node.body().and_then(|x| self.emit_expr(&x)); + let body = if self.should_skip_bodies() { + None + } else { + node.body().and_then(|x| self.emit_expr(&x)) + }; let is_mut = node.mut_token().is_some(); let is_static = node.static_token().is_some(); let is_unsafe = node.unsafe_token().is_some(); @@ -2927,9 +2577,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let statements = node .statements() @@ -2951,9 +2598,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let field_list = node.field_list().and_then(|x| self.emit_field_list(&x)); let generic_param_list = node @@ -2980,9 +2624,6 @@ impl Translator<'_> { &mut self, node: &ast::TokenTree, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let label = self.trap.emit(generated::TokenTree { id: TrapId::Star }); self.emit_location(label, node); emit_detached!(TokenTree, self, node, label); @@ -2993,9 +2634,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let assoc_item_list = node .assoc_item_list() .and_then(|x| self.emit_assoc_item_list(&x)); @@ -3035,9 +2673,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let generic_param_list = node .generic_param_list() @@ -3069,9 +2704,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::TryExpr { @@ -3091,9 +2723,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let fields = node.fields().filter_map(|x| self.emit_expr(&x)).collect(); let label = self.trap.emit(generated::TupleExpr { @@ -3113,9 +2742,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let type_repr = node.ty().and_then(|x| self.emit_type(&x)); let visibility = node.visibility().and_then(|x| self.emit_visibility(&x)); @@ -3134,9 +2760,6 @@ impl Translator<'_> { &mut self, node: &ast::TupleFieldList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let fields = node .fields() .filter_map(|x| self.emit_tuple_field(&x)) @@ -3154,9 +2777,6 @@ impl Translator<'_> { &mut self, node: &ast::TuplePat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let fields = node.fields().filter_map(|x| self.emit_pat(&x)).collect(); let label = self.trap.emit(generated::TuplePat { id: TrapId::Star, @@ -3171,9 +2791,6 @@ impl Translator<'_> { &mut self, node: &ast::TupleStructPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let fields = node.fields().filter_map(|x| self.emit_pat(&x)).collect(); let path = node.path().and_then(|x| self.emit_path(&x)); let label = self.trap.emit(generated::TupleStructPat { @@ -3190,9 +2807,6 @@ impl Translator<'_> { &mut self, node: &ast::TupleType, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let fields = node.fields().filter_map(|x| self.emit_type(&x)).collect(); let label = self.trap.emit(generated::TupleTypeRepr { id: TrapId::Star, @@ -3210,9 +2824,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let generic_param_list = node .generic_param_list() @@ -3245,9 +2856,6 @@ impl Translator<'_> { &mut self, node: &ast::TypeArg, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let type_repr = node.ty().and_then(|x| self.emit_type(&x)); let label = self.trap.emit(generated::TypeArg { id: TrapId::Star, @@ -3262,9 +2870,6 @@ impl Translator<'_> { &mut self, node: &ast::TypeBound, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let is_async = node.async_token().is_some(); let is_const = node.const_token().is_some(); let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x)); @@ -3289,9 +2894,6 @@ impl Translator<'_> { &mut self, node: &ast::TypeBoundList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let bounds = node .bounds() .filter_map(|x| self.emit_type_bound(&x)) @@ -3312,9 +2914,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let default_type = node.default_type().and_then(|x| self.emit_type(&x)); let name = node.name().and_then(|x| self.emit_name(&x)); @@ -3340,9 +2939,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let label = self.trap.emit(generated::UnderscoreExpr { id: TrapId::Star, @@ -3357,9 +2953,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let generic_param_list = node .generic_param_list() @@ -3388,9 +2981,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let use_tree = node.use_tree().and_then(|x| self.emit_use_tree(&x)); let visibility = node.visibility().and_then(|x| self.emit_visibility(&x)); @@ -3409,9 +2999,6 @@ impl Translator<'_> { &mut self, node: &ast::UseBoundGenericArgs, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let use_bound_generic_args = node .use_bound_generic_args() .filter_map(|x| self.emit_use_bound_generic_arg(&x)) @@ -3429,9 +3016,6 @@ impl Translator<'_> { &mut self, node: &ast::UseTree, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let is_glob = node.star_token().is_some(); let path = node.path().and_then(|x| self.emit_path(&x)); let rename = node.rename().and_then(|x| self.emit_rename(&x)); @@ -3454,9 +3038,6 @@ impl Translator<'_> { &mut self, node: &ast::UseTreeList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let use_trees = node .use_trees() .filter_map(|x| self.emit_use_tree(&x)) @@ -3477,9 +3058,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let discriminant = node.expr().and_then(|x| self.emit_expr(&x)); let field_list = node.field_list().and_then(|x| self.emit_field_list(&x)); @@ -3502,9 +3080,6 @@ impl Translator<'_> { &mut self, node: &ast::VariantList, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let variants = node .variants() .filter_map(|x| self.emit_variant(&x)) @@ -3522,9 +3097,6 @@ impl Translator<'_> { &mut self, node: &ast::Visibility, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let path = node.path().and_then(|x| self.emit_path(&x)); let label = self.trap.emit(generated::Visibility { id: TrapId::Star, @@ -3539,9 +3111,6 @@ impl Translator<'_> { &mut self, node: &ast::WhereClause, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let predicates = node .predicates() .filter_map(|x| self.emit_where_pred(&x)) @@ -3559,9 +3128,6 @@ impl Translator<'_> { &mut self, node: &ast::WherePred, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let generic_param_list = node .generic_param_list() .and_then(|x| self.emit_generic_param_list(&x)); @@ -3589,9 +3155,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let condition = node.condition().and_then(|x| self.emit_expr(&x)); let label = node.label().and_then(|x| self.emit_label(&x)); @@ -3612,9 +3175,6 @@ impl Translator<'_> { &mut self, node: &ast::WildcardPat, ) -> Option> { - if self.should_be_excluded(node) { - return None; - } let label = self.trap.emit(generated::WildcardPat { id: TrapId::Star }); self.emit_location(label, node); emit_detached!(WildcardPat, self, node, label); @@ -3628,9 +3188,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::YeetExpr { @@ -3650,9 +3207,6 @@ impl Translator<'_> { if self.should_be_excluded(node) { return None; } - if self.should_be_excluded_attrs(node) { - return None; - } let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect(); let expr = node.expr().and_then(|x| self.emit_expr(&x)); let label = self.trap.emit(generated::YieldExpr { From e37a24a0d0c58e3ba97c07e1a4ace64577b0c5d3 Mon Sep 17 00:00:00 2001 From: Paolo Tranquilli Date: Mon, 26 May 2025 09:54:01 +0200 Subject: [PATCH 2/3] Rust: minor refactoring --- rust/ast-generator/src/main.rs | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/rust/ast-generator/src/main.rs b/rust/ast-generator/src/main.rs index c41a8c4e4b32..18a74f001436 100644 --- a/rust/ast-generator/src/main.rs +++ b/rust/ast-generator/src/main.rs @@ -263,6 +263,7 @@ fn get_additional_fields(node: &AstNodeSrc) -> Vec { "Fn" => vec![FieldInfo::body("body", "BlockExpr")], "Const" => vec![FieldInfo::body("body", "Expr")], "Static" => vec![FieldInfo::body("body", "Expr")], + "Param" => vec![FieldInfo::body("pat", "Pat")], "ClosureExpr" => vec![FieldInfo::optional("body", "Expr")], "ArrayExpr" => vec![FieldInfo::predicate("is_semicolon")], "SelfParam" => vec![FieldInfo::predicate("is_amp")], @@ -290,14 +291,12 @@ fn get_fields(node: &AstNodeSrc) -> Vec { result.extend(get_additional_fields(node)); for field in &node.fields { - match (node.name.as_str(), field.method_name().as_str()) { + let name = field.method_name(); + match (node.name.as_str(), name.as_str()) { ("ArrayExpr", "expr") // The ArrayExpr type also has an 'exprs' field | ("PathSegment", "ty" | "path_type") // these are broken, handling them manually + | ("Param", "pat") // handled manually to use `body` => continue, - ("Param", "pat") => { - result.push(FieldInfo::body("pat", "Pat")); - continue; - }, _ => {} } let ty = match field { @@ -310,7 +309,7 @@ fn get_fields(node: &AstNodeSrc) -> Vec { }, }; result.push(FieldInfo { - name: field.method_name(), + name, ty, }); } From 292cd34efe2b861d185915a3e3e870ed741f6160 Mon Sep 17 00:00:00 2001 From: Paolo Tranquilli Date: Mon, 26 May 2025 10:11:55 +0200 Subject: [PATCH 3/3] Rust: fix format --- rust/ast-generator/src/main.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/rust/ast-generator/src/main.rs b/rust/ast-generator/src/main.rs index 18a74f001436..3c46214d175b 100644 --- a/rust/ast-generator/src/main.rs +++ b/rust/ast-generator/src/main.rs @@ -308,10 +308,7 @@ fn get_fields(node: &AstNodeSrc) -> Vec { Cardinality::Many => FieldType::List(ty.clone()), }, }; - result.push(FieldInfo { - name, - ty, - }); + result.push(FieldInfo { name, ty }); } for trait_ in &node.traits { match trait_.as_str() {