From 44a404571f3e91056a76a234967092aad2455105 Mon Sep 17 00:00:00 2001 From: Arthur Baars Date: Mon, 19 May 2025 21:30:39 +0200 Subject: [PATCH] Rust: fixes --- .../templates/extractor.mustache | 3 +- rust/extractor/src/diagnostics.rs | 17 +- rust/extractor/src/main.rs | 5 +- rust/extractor/src/translate/base.rs | 22 +- rust/extractor/src/translate/generated.rs | 462 ++++++++++++++++++ .../extractor-tests/crate_graph/modules.ql | 14 +- .../library-tests/controlflow/BasicBlocks.ql | 17 +- .../library-tests/operations/Operations.ql | 2 + rust/ql/test/library-tests/variables/Ssa.ql | 17 +- .../test/library-tests/variables/variables.ql | 27 +- 10 files changed, 545 insertions(+), 41 deletions(-) diff --git a/rust/ast-generator/templates/extractor.mustache b/rust/ast-generator/templates/extractor.mustache index c4f8dbd983d..0ce5b863f26 100644 --- a/rust/ast-generator/templates/extractor.mustache +++ b/rust/ast-generator/templates/extractor.mustache @@ -34,8 +34,9 @@ impl Translator<'_> { {{#nodes}} pub(crate) fn emit_{{snake_case_name}}(&mut self, node: &ast::{{ast_name}}) -> Option> { - {{#has_attrs}} if self.should_be_excluded(node) { return None; } + {{#has_attrs}} + if self.should_be_excluded_attrs(node) { return None; } {{/has_attrs}} {{#fields}} {{#predicate}} diff --git a/rust/extractor/src/diagnostics.rs b/rust/extractor/src/diagnostics.rs index b0201e2aed7..0db3358d558 100644 --- a/rust/extractor/src/diagnostics.rs +++ b/rust/extractor/src/diagnostics.rs @@ -1,4 +1,5 @@ use crate::config::Config; +use crate::translate::SourceKind; use anyhow::Context; use chrono::{DateTime, Utc}; use ra_ap_project_model::ProjectManifest; @@ -83,6 +84,8 @@ pub enum ExtractionStepKind { LoadSource, Parse, Extract, + ParseLibrary, + ExtractLibrary, CrateGraph, } @@ -113,18 +116,24 @@ impl ExtractionStep { ) } - pub fn parse(start: Instant, target: &Path) -> Self { + pub fn parse(start: Instant, source_kind: SourceKind, target: &Path) -> Self { Self::new( start, - ExtractionStepKind::Parse, + match source_kind { + SourceKind::Source => ExtractionStepKind::Parse, + SourceKind::Library => ExtractionStepKind::ParseLibrary, + }, Some(PathBuf::from(target)), ) } - pub fn extract(start: Instant, target: &Path) -> Self { + pub fn extract(start: Instant, source_kind: SourceKind, target: &Path) -> Self { Self::new( start, - ExtractionStepKind::Extract, + match source_kind { + SourceKind::Source => ExtractionStepKind::Extract, + SourceKind::Library => ExtractionStepKind::ExtractLibrary, + }, Some(PathBuf::from(target)), ) } diff --git a/rust/extractor/src/main.rs b/rust/extractor/src/main.rs index 38d113d02dc..b9d3ddabd54 100644 --- a/rust/extractor/src/main.rs +++ b/rust/extractor/src/main.rs @@ -63,7 +63,8 @@ impl<'a> Extractor<'a> { errors, semantics_info, } = rust_analyzer.parse(file); - self.steps.push(ExtractionStep::parse(before_parse, file)); + self.steps + .push(ExtractionStep::parse(before_parse, source_kind, file)); let before_extract = Instant::now(); let line_index = LineIndex::new(text.as_ref()); @@ -108,7 +109,7 @@ impl<'a> Extractor<'a> { ) }); self.steps - .push(ExtractionStep::extract(before_extract, file)); + .push(ExtractionStep::extract(before_extract, source_kind, file)); } pub fn extract_with_semantics( diff --git a/rust/extractor/src/translate/base.rs b/rust/extractor/src/translate/base.rs index 43eca8480e4..b60e57cf6d3 100644 --- a/rust/extractor/src/translate/base.rs +++ b/rust/extractor/src/translate/base.rs @@ -93,7 +93,7 @@ pub enum ResolvePaths { Yes, No, } -#[derive(PartialEq, Eq)] +#[derive(Copy, Clone, PartialEq, Eq)] pub enum SourceKind { Source, Library, @@ -619,7 +619,17 @@ impl<'a> Translator<'a> { })(); } - pub(crate) fn should_be_excluded(&self, item: &impl ast::HasAttrs) -> bool { + pub(crate) fn should_be_excluded_attrs(&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)| { + name == "cfg" && sema.check_cfg_attr(&tokens) == Some(false) + }) + }) + }) + } + + pub(crate) fn should_be_excluded(&self, item: &impl ast::AstNode) -> bool { if self.source_kind == SourceKind::Library { let syntax = item.syntax(); if let Some(body) = syntax.parent().and_then(Fn::cast).and_then(|x| x.body()) { @@ -645,13 +655,7 @@ impl<'a> Translator<'a> { } } } - self.semantics.is_some_and(|sema| { - item.attrs().any(|attr| { - attr.as_simple_call().is_some_and(|(name, tokens)| { - name == "cfg" && sema.check_cfg_attr(&tokens) == Some(false) - }) - }) - }) + return false; } 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 5002f09c4d8..84159f970c9 100644 --- a/rust/extractor/src/translate/generated.rs +++ b/rust/extractor/src/translate/generated.rs @@ -242,6 +242,9 @@ 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, @@ -256,6 +259,9 @@ 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, @@ -273,6 +279,9 @@ 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(); @@ -291,6 +300,9 @@ 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 { @@ -307,6 +319,9 @@ 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 }); @@ -319,6 +334,9 @@ 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 { @@ -335,6 +353,9 @@ 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); @@ -348,6 +369,9 @@ 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)) @@ -369,6 +393,9 @@ 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, @@ -383,6 +410,9 @@ 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 { @@ -399,6 +429,9 @@ 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 { @@ -415,6 +448,9 @@ 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, @@ -429,6 +465,9 @@ 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)) @@ -446,6 +485,9 @@ 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() @@ -466,6 +508,9 @@ 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, @@ -477,6 +522,9 @@ 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, @@ -494,6 +542,9 @@ 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)) @@ -513,6 +564,9 @@ 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() @@ -544,6 +598,9 @@ 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, @@ -561,6 +618,9 @@ 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 { @@ -580,6 +640,9 @@ 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 { @@ -599,6 +662,9 @@ 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(); @@ -622,6 +688,9 @@ 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(); @@ -649,6 +718,9 @@ 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, @@ -666,6 +738,9 @@ 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)); @@ -687,6 +762,9 @@ 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)); @@ -708,6 +786,9 @@ 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)); @@ -726,6 +807,9 @@ 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)); @@ -745,6 +829,9 @@ 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 @@ -779,6 +866,9 @@ 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 is_const = node.const_token().is_some(); @@ -805,6 +895,9 @@ 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, @@ -819,6 +912,9 @@ 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 { @@ -838,6 +934,9 @@ 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(); @@ -863,6 +962,9 @@ 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 { @@ -879,6 +981,9 @@ 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)); @@ -895,6 +1000,9 @@ 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() @@ -921,6 +1029,9 @@ 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, @@ -938,6 +1049,9 @@ 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 @@ -963,6 +1077,9 @@ 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)); @@ -986,6 +1103,9 @@ 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() @@ -1008,6 +1128,9 @@ 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)); @@ -1026,6 +1149,9 @@ 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)); @@ -1068,6 +1194,9 @@ 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(); @@ -1095,6 +1224,9 @@ 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)); @@ -1117,6 +1249,9 @@ 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)); @@ -1135,6 +1270,9 @@ 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 { @@ -1154,6 +1292,9 @@ 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)) @@ -1175,6 +1316,9 @@ 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)) @@ -1192,6 +1336,9 @@ 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)) @@ -1212,6 +1359,9 @@ 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(); @@ -1234,6 +1384,9 @@ 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)); @@ -1254,6 +1407,9 @@ 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)); @@ -1290,6 +1446,9 @@ 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)); @@ -1309,6 +1468,9 @@ 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)); @@ -1327,6 +1489,9 @@ 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 }); @@ -1342,6 +1507,9 @@ 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 { @@ -1355,6 +1523,9 @@ 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, @@ -1369,6 +1540,9 @@ 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, @@ -1386,6 +1560,9 @@ 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)); @@ -1407,6 +1584,9 @@ 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)); @@ -1429,6 +1609,9 @@ 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, @@ -1443,6 +1626,9 @@ 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, @@ -1460,6 +1646,9 @@ 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 @@ -1483,6 +1672,9 @@ 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 { @@ -1499,6 +1691,9 @@ 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, @@ -1516,6 +1711,9 @@ 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)); @@ -1537,6 +1735,9 @@ 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)); @@ -1558,6 +1759,9 @@ 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)); @@ -1580,6 +1784,9 @@ 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, @@ -1594,6 +1801,9 @@ 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, @@ -1608,6 +1818,9 @@ 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, @@ -1625,6 +1838,9 @@ 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)); @@ -1645,6 +1861,9 @@ 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() @@ -1664,6 +1883,9 @@ 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, @@ -1681,6 +1903,9 @@ 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)); @@ -1704,6 +1929,9 @@ 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)) @@ -1726,6 +1954,9 @@ 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 @@ -1746,6 +1977,9 @@ 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, @@ -1757,6 +1991,9 @@ 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)); @@ -1780,6 +2017,9 @@ 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 @@ -1804,6 +2044,9 @@ 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)); @@ -1821,6 +2064,9 @@ 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, @@ -1835,6 +2081,9 @@ 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, @@ -1849,6 +2098,9 @@ 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 }); @@ -1864,6 +2116,9 @@ 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() @@ -1882,6 +2137,9 @@ 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, @@ -1896,6 +2154,9 @@ 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 type_repr = node.ty().and_then(|x| self.emit_type(&x)); @@ -1914,6 +2175,9 @@ 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 { @@ -1933,6 +2197,9 @@ 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 { @@ -1949,6 +2216,9 @@ 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, @@ -1963,6 +2233,9 @@ 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, @@ -1977,6 +2250,9 @@ 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)) @@ -1991,6 +2267,9 @@ 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 { @@ -2010,6 +2289,9 @@ 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 { @@ -2026,6 +2308,9 @@ 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, @@ -2040,6 +2325,9 @@ 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)); @@ -2068,6 +2356,9 @@ 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, @@ -2085,6 +2376,9 @@ 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(); @@ -2103,6 +2397,9 @@ 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)); @@ -2124,6 +2421,9 @@ 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(); @@ -2144,6 +2444,9 @@ 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)); @@ -2162,6 +2465,9 @@ 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() @@ -2183,6 +2489,9 @@ 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)); @@ -2204,6 +2513,9 @@ 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() @@ -2228,6 +2540,9 @@ 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(); @@ -2252,6 +2567,9 @@ 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)) @@ -2269,6 +2587,9 @@ 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() @@ -2290,6 +2611,9 @@ 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)); @@ -2308,6 +2632,9 @@ 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)) @@ -2330,6 +2657,9 @@ 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(); @@ -2349,6 +2679,9 @@ 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 { @@ -2365,6 +2698,9 @@ 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)); @@ -2380,6 +2716,9 @@ 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, @@ -2397,6 +2736,9 @@ 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, @@ -2411,6 +2753,9 @@ 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, @@ -2428,6 +2773,9 @@ 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 { @@ -2444,6 +2792,9 @@ 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 }); @@ -2459,6 +2810,9 @@ 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(); @@ -2483,6 +2837,9 @@ 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, @@ -2497,6 +2854,9 @@ 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, @@ -2514,6 +2874,9 @@ 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 { @@ -2530,6 +2893,9 @@ 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 is_mut = node.mut_token().is_some(); @@ -2561,6 +2927,9 @@ 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() @@ -2582,6 +2951,9 @@ 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 @@ -2608,6 +2980,9 @@ 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); @@ -2618,6 +2993,9 @@ 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)); @@ -2657,6 +3035,9 @@ 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() @@ -2688,6 +3069,9 @@ 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 { @@ -2707,6 +3091,9 @@ 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 { @@ -2726,6 +3113,9 @@ 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)); @@ -2744,6 +3134,9 @@ 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)) @@ -2761,6 +3154,9 @@ 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, @@ -2775,6 +3171,9 @@ 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 { @@ -2791,6 +3190,9 @@ 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, @@ -2808,6 +3210,9 @@ 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() @@ -2840,6 +3245,9 @@ 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, @@ -2854,6 +3262,9 @@ 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)); @@ -2878,6 +3289,9 @@ 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)) @@ -2898,6 +3312,9 @@ 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)); @@ -2923,6 +3340,9 @@ 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, @@ -2937,6 +3357,9 @@ 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() @@ -2965,6 +3388,9 @@ 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)); @@ -2983,6 +3409,9 @@ 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)) @@ -3000,6 +3429,9 @@ 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)); @@ -3022,6 +3454,9 @@ 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)) @@ -3042,6 +3477,9 @@ 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)); @@ -3064,6 +3502,9 @@ 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)) @@ -3081,6 +3522,9 @@ 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, @@ -3095,6 +3539,9 @@ 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)) @@ -3112,6 +3559,9 @@ 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)); @@ -3139,6 +3589,9 @@ 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)); @@ -3159,6 +3612,9 @@ 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); @@ -3172,6 +3628,9 @@ 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 { @@ -3191,6 +3650,9 @@ 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 { diff --git a/rust/ql/test/extractor-tests/crate_graph/modules.ql b/rust/ql/test/extractor-tests/crate_graph/modules.ql index 5554a69d1a9..b9db8f9b1e3 100644 --- a/rust/ql/test/extractor-tests/crate_graph/modules.ql +++ b/rust/ql/test/extractor-tests/crate_graph/modules.ql @@ -5,13 +5,16 @@ */ import rust +import codeql.rust.internal.PathResolution predicate nodes(Item i) { i instanceof RelevantNode } -class RelevantNode extends Item { +class RelevantNode extends Element instanceof ItemNode { RelevantNode() { - this.getParentNode*() = - any(Crate m | m.getName() = "test" and m.getVersion() = "0.0.1").getModule() + this.(ItemNode).getImmediateParentModule*() = + any(Crate m | m.getName() = "test" and m.getVersion() = "0.0.1") + .(CrateItemNode) + .getModuleNode() } string label() { result = this.toString() } @@ -26,9 +29,8 @@ class HasGenericParams extends RelevantNode { params = this.(Struct).getGenericParamList() or params = this.(Union).getGenericParamList() or params = this.(Impl).getGenericParamList() or - params = this.(Enum).getGenericParamList() or - params = this.(Trait).getGenericParamList() or - params = this.(TraitAlias).getGenericParamList() + params = this.(Trait).getGenericParamList() // or + //params = this.(TraitAlias).getGenericParamList() } override string label() { diff --git a/rust/ql/test/library-tests/controlflow/BasicBlocks.ql b/rust/ql/test/library-tests/controlflow/BasicBlocks.ql index 2d072fa5b7c..770fd1133e6 100644 --- a/rust/ql/test/library-tests/controlflow/BasicBlocks.ql +++ b/rust/ql/test/library-tests/controlflow/BasicBlocks.ql @@ -1,23 +1,28 @@ import rust import codeql.rust.controlflow.ControlFlowGraph import codeql.rust.controlflow.BasicBlocks +import TestUtils -query predicate dominates(BasicBlock bb1, BasicBlock bb2) { bb1.dominates(bb2) } +query predicate dominates(BasicBlock bb1, BasicBlock bb2) { + toBeTested(bb1.getScope()) and bb1.dominates(bb2) +} -query predicate postDominance(BasicBlock bb1, BasicBlock bb2) { bb1.postDominates(bb2) } +query predicate postDominance(BasicBlock bb1, BasicBlock bb2) { + toBeTested(bb1.getScope()) and bb1.postDominates(bb2) +} query predicate immediateDominator(BasicBlock bb1, BasicBlock bb2) { - bb1.getImmediateDominator() = bb2 + toBeTested(bb1.getScope()) and bb1.getImmediateDominator() = bb2 } query predicate controls(ConditionBasicBlock bb1, BasicBlock bb2, SuccessorType t) { - bb1.edgeDominates(bb2, t) + toBeTested(bb1.getScope()) and bb1.edgeDominates(bb2, t) } query predicate successor(ConditionBasicBlock bb1, BasicBlock bb2, SuccessorType t) { - bb1.getASuccessor(t) = bb2 + toBeTested(bb1.getScope()) and bb1.getASuccessor(t) = bb2 } query predicate joinBlockPredecessor(JoinBasicBlock bb1, BasicBlock bb2, int i) { - bb1.getJoinBlockPredecessor(i) = bb2 + toBeTested(bb1.getScope()) and bb1.getJoinBlockPredecessor(i) = bb2 } diff --git a/rust/ql/test/library-tests/operations/Operations.ql b/rust/ql/test/library-tests/operations/Operations.ql index cbb81bdcb02..71929f26a12 100644 --- a/rust/ql/test/library-tests/operations/Operations.ql +++ b/rust/ql/test/library-tests/operations/Operations.ql @@ -1,5 +1,6 @@ import rust import utils.test.InlineExpectationsTest +import TestUtils string describe(Expr op) { op instanceof Operation and result = "Operation" @@ -20,6 +21,7 @@ module OperationsTest implements TestSig { predicate hasActualResult(Location location, string element, string tag, string value) { exists(Expr op | + toBeTested(op) and location = op.getLocation() and location.getFile().getBaseName() != "" and element = op.toString() and diff --git a/rust/ql/test/library-tests/variables/Ssa.ql b/rust/ql/test/library-tests/variables/Ssa.ql index c972bb2747c..d93a1f13b64 100644 --- a/rust/ql/test/library-tests/variables/Ssa.ql +++ b/rust/ql/test/library-tests/variables/Ssa.ql @@ -4,31 +4,38 @@ import codeql.rust.controlflow.ControlFlowGraph import codeql.rust.dataflow.Ssa import codeql.rust.dataflow.internal.SsaImpl import Impl::TestAdjacentRefs as RefTest +import TestUtils -query predicate definition(Ssa::Definition def, Variable v) { def.getSourceVariable() = v } +query predicate definition(Ssa::Definition def, Variable v) { + toBeTested(v.getEnclosingCfgScope()) and def.getSourceVariable() = v +} query predicate read(Ssa::Definition def, Variable v, CfgNode read) { - def.getSourceVariable() = v and read = def.getARead() + toBeTested(v.getEnclosingCfgScope()) and def.getSourceVariable() = v and read = def.getARead() } query predicate firstRead(Ssa::Definition def, Variable v, CfgNode read) { - def.getSourceVariable() = v and read = def.getAFirstRead() + toBeTested(v.getEnclosingCfgScope()) and + def.getSourceVariable() = v and + read = def.getAFirstRead() } query predicate adjacentReads(Ssa::Definition def, Variable v, CfgNode read1, CfgNode read2) { + toBeTested(v.getEnclosingCfgScope()) and def.getSourceVariable() = v and def.hasAdjacentReads(read1, read2) } query predicate phi(Ssa::PhiDefinition phi, Variable v, Ssa::Definition input) { - phi.getSourceVariable() = v and input = phi.getAnInput() + toBeTested(v.getEnclosingCfgScope()) and phi.getSourceVariable() = v and input = phi.getAnInput() } query predicate phiReadNode(RefTest::Ref phi, Variable v) { - phi.isPhiRead() and phi.getSourceVariable() = v + toBeTested(v.getEnclosingCfgScope()) and phi.isPhiRead() and phi.getSourceVariable() = v } query predicate phiReadNodeFirstRead(RefTest::Ref phi, Variable v, CfgNode read) { + toBeTested(v.getEnclosingCfgScope()) and exists(RefTest::Ref r, BasicBlock bb, int i | phi.isPhiRead() and RefTest::adjacentRefRead(phi, r) and diff --git a/rust/ql/test/library-tests/variables/variables.ql b/rust/ql/test/library-tests/variables/variables.ql index 121975c0c82..dbde4f56e85 100644 --- a/rust/ql/test/library-tests/variables/variables.ql +++ b/rust/ql/test/library-tests/variables/variables.ql @@ -1,29 +1,39 @@ import rust import utils.test.InlineExpectationsTest import codeql.rust.elements.internal.VariableImpl::Impl as VariableImpl +import TestUtils -query predicate variable(Variable v) { any() } +query predicate variable(Variable v) { toBeTested(v.getEnclosingCfgScope()) } -query predicate variableAccess(VariableAccess va, Variable v) { v = va.getVariable() } +query predicate variableAccess(VariableAccess va, Variable v) { + variable(v) and toBeTested(va) and v = va.getVariable() +} -query predicate variableWriteAccess(VariableWriteAccess va, Variable v) { v = va.getVariable() } +query predicate variableWriteAccess(VariableWriteAccess va, Variable v) { + variable(v) and toBeTested(va) and v = va.getVariable() +} -query predicate variableReadAccess(VariableReadAccess va, Variable v) { v = va.getVariable() } +query predicate variableReadAccess(VariableReadAccess va, Variable v) { + variable(v) and toBeTested(va) and v = va.getVariable() +} -query predicate variableInitializer(Variable v, Expr e) { e = v.getInitializer() } +query predicate variableInitializer(Variable v, Expr e) { + variable(v) and toBeTested(e) and e = v.getInitializer() +} -query predicate capturedVariable(Variable v) { v.isCaptured() } +query predicate capturedVariable(Variable v) { variable(v) and v.isCaptured() } -query predicate capturedAccess(VariableAccess va) { va.isCapture() } +query predicate capturedAccess(VariableAccess va) { toBeTested(va) and va.isCapture() } query predicate nestedFunctionAccess(VariableImpl::NestedFunctionAccess nfa, Function f) { - f = nfa.getFunction() + toBeTested(f) and f = nfa.getFunction() } module VariableAccessTest implements TestSig { string getARelevantTag() { result = ["", "write_", "read_"] + "access" } private predicate declAt(Variable v, string filepath, int line, boolean inMacro) { + variable(v) and v.getLocation().hasLocationInfo(filepath, _, _, line, _) and if v.getPat().isInMacroExpansion() then inMacro = true else inMacro = false } @@ -46,6 +56,7 @@ module VariableAccessTest implements TestSig { predicate hasActualResult(Location location, string element, string tag, string value) { exists(VariableAccess va | + toBeTested(va) and location = va.getLocation() and element = va.toString() and decl(va.getVariable(), value)