diff --git a/rust/ast-generator/src/main.rs b/rust/ast-generator/src/main.rs index 83999711161d..70741c83382c 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,95 @@ 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::body("args", "TokenTree"), + FieldInfo::body("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, - }], + "MacroCall" => vec![FieldInfo::body("token_tree", "TokenTree")], + "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")], + "Param" => vec![FieldInfo::body("pat", "Pat")], + "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![], } } @@ -352,9 +292,11 @@ 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") | ("MacroCall", "token_tree") // handled manually to use `body` => continue, _ => {} } @@ -367,61 +309,30 @@ fn get_fields(node: &AstNodeSrc) -> Vec { Cardinality::Many => FieldType::List(ty.clone()), }, }; - result.push(FieldInfo { - name: field.method_name(), - ty, - }); + result.push(FieldInfo { name, ty }); } 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 +366,7 @@ struct ExtractorNodeFieldInfo { predicate: bool, optional: bool, list: bool, + body: bool, } #[derive(Serialize)] @@ -518,6 +430,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 b94f8a6043a7..ab1fd4b0d378 100644 --- a/rust/ast-generator/templates/extractor.mustache +++ b/rust/ast-generator/templates/extractor.mustache @@ -36,23 +36,27 @@ impl Translator<'_> { pub(crate) fn emit_{{snake_case_name}}(&mut self, node: &ast::{{ast_name}}) -> Option> { pre_emit!({{name}}, self, node); - 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 8d971900497e..4f138b00ef0a 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, @@ -644,7 +644,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)| { @@ -654,46 +654,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; - } - if syntax.kind() == SyntaxKind::TOKEN_TREE { - 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 cd0c2f9a9d96..be8f23f9cfbe 100644 --- a/rust/extractor/src/translate/generated.rs +++ b/rust/extractor/src/translate/generated.rs @@ -256,9 +256,6 @@ impl Translator<'_> { } pub(crate) fn emit_abi(&mut self, node: &ast::Abi) -> Option> { pre_emit!(Abi, self, node); - 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, @@ -274,9 +271,6 @@ impl Translator<'_> { node: &ast::ArgList, ) -> Option> { pre_emit!(ArgList, self, node); - 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, @@ -295,9 +289,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(); @@ -317,9 +308,6 @@ impl Translator<'_> { node: &ast::ArrayType, ) -> Option> { pre_emit!(ArrayTypeRepr, self, node); - 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 { @@ -337,9 +325,6 @@ impl Translator<'_> { node: &ast::AsmClobberAbi, ) -> Option> { pre_emit!(AsmClobberAbi, self, node); - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::AsmClobberAbi { id: TrapId::Star }); @@ -353,9 +338,6 @@ impl Translator<'_> { node: &ast::AsmConst, ) -> Option> { pre_emit!(AsmConst, self, node); - 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 { @@ -373,9 +355,6 @@ impl Translator<'_> { node: &ast::AsmDirSpec, ) -> Option> { pre_emit!(AsmDirSpec, self, node); - if self.should_be_excluded(node) { - return None; - } let label = self.trap.emit(generated::AsmDirSpec { id: TrapId::Star }); self.emit_location(label, node); post_emit!(AsmDirSpec, self, node, label); @@ -390,9 +369,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)) @@ -415,9 +391,6 @@ impl Translator<'_> { node: &ast::AsmLabel, ) -> Option> { pre_emit!(AsmLabel, self, node); - 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, @@ -433,9 +406,6 @@ impl Translator<'_> { node: &ast::AsmOperandExpr, ) -> Option> { pre_emit!(AsmOperandExpr, self, node); - 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 { @@ -453,9 +423,6 @@ impl Translator<'_> { node: &ast::AsmOperandNamed, ) -> Option> { pre_emit!(AsmOperandNamed, self, node); - 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 { @@ -473,9 +440,6 @@ impl Translator<'_> { node: &ast::AsmOption, ) -> Option> { pre_emit!(AsmOption, self, node); - 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, @@ -491,9 +455,6 @@ impl Translator<'_> { node: &ast::AsmOptions, ) -> Option> { pre_emit!(AsmOptionsList, self, node); - if self.should_be_excluded(node) { - return None; - } let asm_options = node .asm_options() .filter_map(|x| self.emit_asm_option(&x)) @@ -512,9 +473,6 @@ impl Translator<'_> { node: &ast::AsmRegOperand, ) -> Option> { pre_emit!(AsmRegOperand, self, node); - 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() @@ -536,9 +494,6 @@ impl Translator<'_> { node: &ast::AsmRegSpec, ) -> Option> { pre_emit!(AsmRegSpec, self, node); - 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, @@ -551,9 +506,6 @@ impl Translator<'_> { } pub(crate) fn emit_asm_sym(&mut self, node: &ast::AsmSym) -> Option> { pre_emit!(AsmSym, self, node); - 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, @@ -572,9 +524,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)) @@ -595,9 +544,6 @@ impl Translator<'_> { node: &ast::AssocTypeArg, ) -> Option> { pre_emit!(AssocTypeArg, self, node); - 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() @@ -630,9 +576,6 @@ impl Translator<'_> { } pub(crate) fn emit_attr(&mut self, node: &ast::Attr) -> Option> { pre_emit!(Attr, self, node); - 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, @@ -651,9 +594,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 { @@ -674,9 +614,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 { @@ -697,9 +634,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(); @@ -724,9 +658,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(); @@ -755,9 +686,6 @@ impl Translator<'_> { } pub(crate) fn emit_box_pat(&mut self, node: &ast::BoxPat) -> Option> { pre_emit!(BoxPat, self, node); - 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, @@ -776,9 +704,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)); @@ -801,9 +726,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)); @@ -826,9 +748,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)); @@ -848,9 +767,6 @@ impl Translator<'_> { node: &ast::ClosureBinder, ) -> Option> { pre_emit!(ClosureBinder, self, node); - 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)); @@ -871,9 +787,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 @@ -909,11 +822,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)); @@ -939,9 +853,6 @@ impl Translator<'_> { node: &ast::ConstArg, ) -> Option> { pre_emit!(ConstArg, self, node); - 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, @@ -957,9 +868,6 @@ impl Translator<'_> { node: &ast::ConstBlockPat, ) -> Option> { pre_emit!(ConstBlockPat, self, node); - 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 { @@ -980,9 +888,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(); @@ -1009,9 +914,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 { @@ -1029,9 +931,6 @@ impl Translator<'_> { node: &ast::DynTraitType, ) -> Option> { pre_emit!(DynTraitTypeRepr, self, node); - 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)); @@ -1049,9 +948,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() @@ -1079,9 +975,6 @@ impl Translator<'_> { node: &ast::ExprStmt, ) -> Option> { pre_emit!(ExprStmt, self, node); - 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, @@ -1100,9 +993,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 @@ -1129,9 +1019,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)); @@ -1156,9 +1043,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() @@ -1182,9 +1066,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)); @@ -1204,12 +1085,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)); @@ -1250,9 +1132,6 @@ impl Translator<'_> { node: &ast::FnPtrType, ) -> Option> { pre_emit!(FnPtrTypeRepr, self, node); - 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(); @@ -1281,9 +1160,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)); @@ -1307,9 +1183,6 @@ impl Translator<'_> { node: &ast::ForType, ) -> Option> { pre_emit!(ForTypeRepr, self, node); - 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)); @@ -1329,9 +1202,6 @@ impl Translator<'_> { node: &ast::FormatArgsArg, ) -> Option> { pre_emit!(FormatArgsArg, self, node); - 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 { @@ -1352,9 +1222,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)) @@ -1377,9 +1244,6 @@ impl Translator<'_> { node: &ast::GenericArgList, ) -> Option> { pre_emit!(GenericArgList, self, node); - if self.should_be_excluded(node) { - return None; - } let generic_args = node .generic_args() .filter_map(|x| self.emit_generic_arg(&x)) @@ -1398,9 +1262,6 @@ impl Translator<'_> { node: &ast::GenericParamList, ) -> Option> { pre_emit!(GenericParamList, self, node); - if self.should_be_excluded(node) { - return None; - } let generic_params = node .generic_params() .filter_map(|x| self.emit_generic_param(&x)) @@ -1422,9 +1283,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(); @@ -1448,9 +1306,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)); @@ -1472,9 +1327,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)); @@ -1512,9 +1364,6 @@ impl Translator<'_> { node: &ast::ImplTraitType, ) -> Option> { pre_emit!(ImplTraitTypeRepr, self, node); - 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)); @@ -1535,9 +1384,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)); @@ -1557,9 +1403,6 @@ impl Translator<'_> { node: &ast::InferType, ) -> Option> { pre_emit!(InferTypeRepr, self, node); - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::InferTypeRepr { id: TrapId::Star }); @@ -1576,9 +1419,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 { @@ -1593,9 +1433,6 @@ impl Translator<'_> { } pub(crate) fn emit_label(&mut self, node: &ast::Label) -> Option> { pre_emit!(Label, self, node); - 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, @@ -1611,9 +1448,6 @@ impl Translator<'_> { node: &ast::LetElse, ) -> Option> { pre_emit!(LetElse, self, node); - 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, @@ -1632,9 +1466,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)); @@ -1657,9 +1488,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)); @@ -1683,9 +1511,6 @@ impl Translator<'_> { node: &ast::Lifetime, ) -> Option> { pre_emit!(Lifetime, self, node); - if self.should_be_excluded(node) { - return None; - } let text = node.try_get_text(); let label = self.trap.emit(generated::Lifetime { id: TrapId::Star, @@ -1701,9 +1526,6 @@ impl Translator<'_> { node: &ast::LifetimeArg, ) -> Option> { pre_emit!(LifetimeArg, self, node); - 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, @@ -1722,9 +1544,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 @@ -1749,9 +1568,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 { @@ -1769,9 +1585,6 @@ impl Translator<'_> { node: &ast::LiteralPat, ) -> Option> { pre_emit!(LiteralPat, self, node); - 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, @@ -1790,9 +1603,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)); @@ -1815,12 +1625,13 @@ 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)); + let token_tree = if self.should_skip_bodies() { + None + } else { + node.token_tree().and_then(|x| self.emit_token_tree(&x)) + }; let label = self.trap.emit(generated::MacroCall { id: TrapId::Star, attrs, @@ -1840,12 +1651,17 @@ 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 args = if self.should_skip_bodies() { + None + } else { + 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)); + let body = if self.should_skip_bodies() { + None + } else { + node.body().and_then(|x| self.emit_token_tree(&x)) + }; let name = node.name().and_then(|x| self.emit_name(&x)); let visibility = node.visibility().and_then(|x| self.emit_visibility(&x)); let label = self.trap.emit(generated::MacroDef { @@ -1866,9 +1682,6 @@ impl Translator<'_> { node: &ast::MacroExpr, ) -> Option> { pre_emit!(MacroExpr, self, node); - 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, @@ -1884,9 +1697,6 @@ impl Translator<'_> { node: &ast::MacroItems, ) -> Option> { pre_emit!(MacroItems, self, node); - 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, @@ -1902,9 +1712,6 @@ impl Translator<'_> { node: &ast::MacroPat, ) -> Option> { pre_emit!(MacroPat, self, node); - 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, @@ -1923,9 +1730,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)); @@ -1947,9 +1751,6 @@ impl Translator<'_> { node: &ast::MacroStmts, ) -> Option> { pre_emit!(MacroBlockExpr, self, node); - if self.should_be_excluded(node) { - return None; - } let tail_expr = node.expr().and_then(|x| self.emit_expr(&x)); let statements = node .statements() @@ -1970,9 +1771,6 @@ impl Translator<'_> { node: &ast::MacroType, ) -> Option> { pre_emit!(MacroTypeRepr, self, node); - 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, @@ -1991,9 +1789,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)); @@ -2018,9 +1813,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)) @@ -2044,9 +1836,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 @@ -2068,9 +1857,6 @@ impl Translator<'_> { node: &ast::MatchGuard, ) -> Option> { pre_emit!(MatchGuard, self, node); - 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, @@ -2083,9 +1869,6 @@ impl Translator<'_> { } pub(crate) fn emit_meta(&mut self, node: &ast::Meta) -> Option> { pre_emit!(Meta, self, node); - 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)); @@ -2110,9 +1893,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 @@ -2138,9 +1918,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)); @@ -2159,9 +1936,6 @@ impl Translator<'_> { } pub(crate) fn emit_name(&mut self, node: &ast::Name) -> Option> { pre_emit!(Name, self, node); - if self.should_be_excluded(node) { - return None; - } let text = node.try_get_text(); let label = self.trap.emit(generated::Name { id: TrapId::Star, @@ -2177,9 +1951,6 @@ impl Translator<'_> { node: &ast::NameRef, ) -> Option> { pre_emit!(NameRef, self, node); - if self.should_be_excluded(node) { - return None; - } let text = node.try_get_text(); let label = self.trap.emit(generated::NameRef { id: TrapId::Star, @@ -2195,9 +1966,6 @@ impl Translator<'_> { node: &ast::NeverType, ) -> Option> { pre_emit!(NeverTypeRepr, self, node); - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::NeverTypeRepr { id: TrapId::Star }); @@ -2214,9 +1982,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() @@ -2236,9 +2001,6 @@ impl Translator<'_> { } pub(crate) fn emit_or_pat(&mut self, node: &ast::OrPat) -> Option> { pre_emit!(OrPat, self, node); - 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, @@ -2254,11 +2016,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, @@ -2276,9 +2039,6 @@ impl Translator<'_> { node: &ast::ParamList, ) -> Option> { pre_emit!(ParamList, self, node); - 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 { @@ -2299,9 +2059,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 { @@ -2319,9 +2076,6 @@ impl Translator<'_> { node: &ast::ParenPat, ) -> Option> { pre_emit!(ParenPat, self, node); - 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, @@ -2337,9 +2091,6 @@ impl Translator<'_> { node: &ast::ParenType, ) -> Option> { pre_emit!(ParenTypeRepr, self, node); - 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, @@ -2355,9 +2106,6 @@ impl Translator<'_> { node: &ast::ParenthesizedArgList, ) -> Option> { pre_emit!(ParenthesizedArgList, self, node); - if self.should_be_excluded(node) { - return None; - } let type_args = node .type_args() .filter_map(|x| self.emit_type_arg(&x)) @@ -2373,9 +2121,6 @@ impl Translator<'_> { } pub(crate) fn emit_path(&mut self, node: &ast::Path) -> Option> { pre_emit!(Path, self, node); - 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 { @@ -2396,9 +2141,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 { @@ -2416,9 +2158,6 @@ impl Translator<'_> { node: &ast::PathPat, ) -> Option> { pre_emit!(PathPat, self, node); - 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, @@ -2434,9 +2173,6 @@ impl Translator<'_> { node: &ast::PathSegment, ) -> Option> { pre_emit!(PathSegment, self, node); - 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)); @@ -2466,9 +2202,6 @@ impl Translator<'_> { node: &ast::PathType, ) -> Option> { pre_emit!(PathTypeRepr, self, node); - 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, @@ -2487,9 +2220,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(); @@ -2509,9 +2239,6 @@ impl Translator<'_> { node: &ast::PtrType, ) -> Option> { pre_emit!(PtrTypeRepr, self, node); - 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)); @@ -2534,9 +2261,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(); @@ -2558,9 +2282,6 @@ impl Translator<'_> { node: &ast::RangePat, ) -> Option> { pre_emit!(RangePat, self, node); - 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)); @@ -2580,9 +2301,6 @@ impl Translator<'_> { node: &ast::RecordExpr, ) -> Option> { pre_emit!(StructExpr, self, node); - 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() @@ -2605,9 +2323,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)); @@ -2630,9 +2345,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() @@ -2658,9 +2370,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(); @@ -2686,9 +2395,6 @@ impl Translator<'_> { node: &ast::RecordFieldList, ) -> Option> { pre_emit!(StructFieldList, self, node); - if self.should_be_excluded(node) { - return None; - } let fields = node .fields() .filter_map(|x| self.emit_record_field(&x)) @@ -2707,9 +2413,6 @@ impl Translator<'_> { node: &ast::RecordPat, ) -> Option> { pre_emit!(StructPat, self, node); - 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() @@ -2732,9 +2435,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)); @@ -2754,9 +2454,6 @@ impl Translator<'_> { node: &ast::RecordPatFieldList, ) -> Option> { pre_emit!(StructPatFieldList, self, node); - if self.should_be_excluded(node) { - return None; - } let fields = node .fields() .filter_map(|x| self.emit_record_pat_field(&x)) @@ -2780,9 +2477,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(); @@ -2803,9 +2497,6 @@ impl Translator<'_> { } pub(crate) fn emit_ref_pat(&mut self, node: &ast::RefPat) -> Option> { pre_emit!(RefPat, self, node); - 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 { @@ -2823,9 +2514,6 @@ impl Translator<'_> { node: &ast::RefType, ) -> Option> { pre_emit!(RefTypeRepr, self, node); - 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)); @@ -2842,9 +2530,6 @@ impl Translator<'_> { } pub(crate) fn emit_rename(&mut self, node: &ast::Rename) -> Option> { pre_emit!(Rename, self, node); - 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, @@ -2863,9 +2548,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, @@ -2881,9 +2563,6 @@ impl Translator<'_> { node: &ast::RetType, ) -> Option> { pre_emit!(RetTypeRepr, self, node); - 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, @@ -2902,9 +2581,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 { @@ -2922,9 +2598,6 @@ impl Translator<'_> { node: &ast::ReturnTypeSyntax, ) -> Option> { pre_emit!(ReturnTypeSyntax, self, node); - if self.should_be_excluded(node) { - return None; - } let label = self .trap .emit(generated::ReturnTypeSyntax { id: TrapId::Star }); @@ -2941,9 +2614,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(); @@ -2969,9 +2639,6 @@ impl Translator<'_> { node: &ast::SlicePat, ) -> Option> { pre_emit!(SlicePat, self, node); - 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, @@ -2987,9 +2654,6 @@ impl Translator<'_> { node: &ast::SliceType, ) -> Option> { pre_emit!(SliceTypeRepr, self, node); - 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, @@ -3008,9 +2672,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 { @@ -3028,11 +2689,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(); @@ -3063,9 +2725,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() @@ -3088,9 +2747,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 @@ -3118,9 +2774,6 @@ impl Translator<'_> { node: &ast::TokenTree, ) -> Option> { pre_emit!(TokenTree, self, node); - if self.should_be_excluded(node) { - return None; - } let label = self.trap.emit(generated::TokenTree { id: TrapId::Star }); self.emit_location(label, node); post_emit!(TokenTree, self, node, label); @@ -3132,9 +2785,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)); @@ -3175,9 +2825,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() @@ -3210,9 +2857,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 { @@ -3233,9 +2877,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 { @@ -3256,9 +2897,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)); @@ -3278,9 +2916,6 @@ impl Translator<'_> { node: &ast::TupleFieldList, ) -> Option> { pre_emit!(TupleFieldList, self, node); - if self.should_be_excluded(node) { - return None; - } let fields = node .fields() .filter_map(|x| self.emit_tuple_field(&x)) @@ -3299,9 +2934,6 @@ impl Translator<'_> { node: &ast::TuplePat, ) -> Option> { pre_emit!(TuplePat, self, node); - 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, @@ -3317,9 +2949,6 @@ impl Translator<'_> { node: &ast::TupleStructPat, ) -> Option> { pre_emit!(TupleStructPat, self, node); - 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 { @@ -3337,9 +2966,6 @@ impl Translator<'_> { node: &ast::TupleType, ) -> Option> { pre_emit!(TupleTypeRepr, self, node); - 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, @@ -3358,9 +2984,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() @@ -3394,9 +3017,6 @@ impl Translator<'_> { node: &ast::TypeArg, ) -> Option> { pre_emit!(TypeArg, self, node); - 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, @@ -3412,9 +3032,6 @@ impl Translator<'_> { node: &ast::TypeBound, ) -> Option> { pre_emit!(TypeBound, self, node); - 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)); @@ -3440,9 +3057,6 @@ impl Translator<'_> { node: &ast::TypeBoundList, ) -> Option> { pre_emit!(TypeBoundList, self, node); - if self.should_be_excluded(node) { - return None; - } let bounds = node .bounds() .filter_map(|x| self.emit_type_bound(&x)) @@ -3464,9 +3078,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)); @@ -3493,9 +3104,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, @@ -3511,9 +3119,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() @@ -3543,9 +3148,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)); @@ -3565,9 +3167,6 @@ impl Translator<'_> { node: &ast::UseBoundGenericArgs, ) -> Option> { pre_emit!(UseBoundGenericArgs, self, node); - 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)) @@ -3586,9 +3185,6 @@ impl Translator<'_> { node: &ast::UseTree, ) -> Option> { pre_emit!(UseTree, self, node); - 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)); @@ -3612,9 +3208,6 @@ impl Translator<'_> { node: &ast::UseTreeList, ) -> Option> { pre_emit!(UseTreeList, self, node); - if self.should_be_excluded(node) { - return None; - } let use_trees = node .use_trees() .filter_map(|x| self.emit_use_tree(&x)) @@ -3636,9 +3229,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)); @@ -3662,9 +3252,6 @@ impl Translator<'_> { node: &ast::VariantList, ) -> Option> { pre_emit!(VariantList, self, node); - if self.should_be_excluded(node) { - return None; - } let variants = node .variants() .filter_map(|x| self.emit_variant(&x)) @@ -3683,9 +3270,6 @@ impl Translator<'_> { node: &ast::Visibility, ) -> Option> { pre_emit!(Visibility, self, node); - 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, @@ -3701,9 +3285,6 @@ impl Translator<'_> { node: &ast::WhereClause, ) -> Option> { pre_emit!(WhereClause, self, node); - if self.should_be_excluded(node) { - return None; - } let predicates = node .predicates() .filter_map(|x| self.emit_where_pred(&x)) @@ -3722,9 +3303,6 @@ impl Translator<'_> { node: &ast::WherePred, ) -> Option> { pre_emit!(WherePred, self, node); - 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)); @@ -3753,9 +3331,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)); @@ -3777,9 +3352,6 @@ impl Translator<'_> { node: &ast::WildcardPat, ) -> Option> { pre_emit!(WildcardPat, self, node); - if self.should_be_excluded(node) { - return None; - } let label = self.trap.emit(generated::WildcardPat { id: TrapId::Star }); self.emit_location(label, node); post_emit!(WildcardPat, self, node, label); @@ -3794,9 +3366,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 { @@ -3817,9 +3386,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 {