From bc862b897d10ae554a12d92001797cad1a59fd93 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Thu, 31 Oct 2024 09:27:46 +0100 Subject: Move child_by_source from hir-def to hir --- .../crates/hir-def/src/child_by_source.rs | 271 --------------------- .../rust-analyzer/crates/hir-def/src/dyn_map.rs | 74 +++++- .../crates/hir-def/src/dyn_map/keys.rs | 72 ------ .../rust-analyzer/crates/hir-def/src/item_scope.rs | 10 +- src/tools/rust-analyzer/crates/hir-def/src/lib.rs | 7 +- .../rust-analyzer/crates/hir/src/semantics.rs | 1 + .../crates/hir/src/semantics/child_by_source.rs | 271 +++++++++++++++++++++ .../crates/hir/src/semantics/source_to_def.rs | 6 +- .../convert_tuple_struct_to_named_struct.rs | 2 +- .../crates/ide-diagnostics/src/lib.rs | 2 +- 10 files changed, 357 insertions(+), 359 deletions(-) delete mode 100644 src/tools/rust-analyzer/crates/hir-def/src/child_by_source.rs delete mode 100644 src/tools/rust-analyzer/crates/hir-def/src/dyn_map/keys.rs create mode 100644 src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs (limited to 'src/tools/rust-analyzer') diff --git a/src/tools/rust-analyzer/crates/hir-def/src/child_by_source.rs b/src/tools/rust-analyzer/crates/hir-def/src/child_by_source.rs deleted file mode 100644 index 0438278ca27..00000000000 --- a/src/tools/rust-analyzer/crates/hir-def/src/child_by_source.rs +++ /dev/null @@ -1,271 +0,0 @@ -//! When *constructing* `hir`, we start at some parent syntax node and recursively -//! lower the children. -//! -//! This module allows one to go in the opposite direction: start with a syntax -//! node for a *child*, and get its hir. - -use either::Either; -use hir_expand::{attrs::collect_attrs, HirFileId}; -use syntax::{ast, AstPtr}; - -use crate::{ - db::DefDatabase, - dyn_map::{ - keys::{self, Key}, - DynMap, - }, - item_scope::ItemScope, - item_tree::ItemTreeNode, - nameres::DefMap, - src::{HasChildSource, HasSource}, - AdtId, AssocItemId, DefWithBodyId, EnumId, FieldId, GenericDefId, ImplId, ItemTreeLoc, - LifetimeParamId, Lookup, MacroId, ModuleDefId, ModuleId, TraitId, TypeOrConstParamId, - VariantId, -}; - -pub trait ChildBySource { - fn child_by_source(&self, db: &dyn DefDatabase, file_id: HirFileId) -> DynMap { - let mut res = DynMap::default(); - self.child_by_source_to(db, &mut res, file_id); - res - } - fn child_by_source_to(&self, db: &dyn DefDatabase, map: &mut DynMap, file_id: HirFileId); -} - -impl ChildBySource for TraitId { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { - let data = db.trait_data(*self); - - data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each( - |(ast_id, call_id)| { - res[keys::ATTR_MACRO_CALL].insert(ast_id.to_ptr(db.upcast()), call_id); - }, - ); - data.items.iter().for_each(|&(_, item)| { - add_assoc_item(db, res, file_id, item); - }); - } -} - -impl ChildBySource for ImplId { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { - let data = db.impl_data(*self); - // FIXME: Macro calls - data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each( - |(ast_id, call_id)| { - res[keys::ATTR_MACRO_CALL].insert(ast_id.to_ptr(db.upcast()), call_id); - }, - ); - data.items.iter().for_each(|&item| { - add_assoc_item(db, res, file_id, item); - }); - } -} - -impl ChildBySource for ModuleId { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { - let def_map = self.def_map(db); - let module_data = &def_map[self.local_id]; - module_data.scope.child_by_source_to(db, res, file_id); - } -} - -impl ChildBySource for ItemScope { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { - self.declarations().for_each(|item| add_module_def(db, res, file_id, item)); - self.impls().for_each(|imp| insert_item_loc(db, res, file_id, imp, keys::IMPL)); - self.extern_crate_decls() - .for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::EXTERN_CRATE)); - self.use_decls().for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::USE)); - self.unnamed_consts() - .for_each(|konst| insert_item_loc(db, res, file_id, konst, keys::CONST)); - self.attr_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each( - |(ast_id, call_id)| { - res[keys::ATTR_MACRO_CALL].insert(ast_id.to_ptr(db.upcast()), call_id); - }, - ); - self.legacy_macros().for_each(|(_, ids)| { - ids.iter().for_each(|&id| { - if let MacroId::MacroRulesId(id) = id { - let loc = id.lookup(db); - if loc.id.file_id() == file_id { - res[keys::MACRO_RULES].insert(loc.ast_ptr(db).value, id); - } - } - }) - }); - self.derive_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each( - |(ast_id, calls)| { - let adt = ast_id.to_node(db.upcast()); - calls.for_each(|(attr_id, call_id, calls)| { - if let Some((_, Either::Left(attr))) = - collect_attrs(&adt).nth(attr_id.ast_index()) - { - res[keys::DERIVE_MACRO_CALL] - .insert(AstPtr::new(&attr), (attr_id, call_id, calls.into())); - } - }); - }, - ); - self.iter_macro_invoc().filter(|(id, _)| id.file_id == file_id).for_each( - |(ast_id, &call)| { - let ast = ast_id.to_ptr(db.upcast()); - res[keys::MACRO_CALL].insert(ast, call); - }, - ); - fn add_module_def( - db: &dyn DefDatabase, - map: &mut DynMap, - file_id: HirFileId, - item: ModuleDefId, - ) { - match item { - ModuleDefId::FunctionId(id) => { - insert_item_loc(db, map, file_id, id, keys::FUNCTION) - } - ModuleDefId::ConstId(id) => insert_item_loc(db, map, file_id, id, keys::CONST), - ModuleDefId::TypeAliasId(id) => { - insert_item_loc(db, map, file_id, id, keys::TYPE_ALIAS) - } - ModuleDefId::StaticId(id) => insert_item_loc(db, map, file_id, id, keys::STATIC), - ModuleDefId::TraitId(id) => insert_item_loc(db, map, file_id, id, keys::TRAIT), - ModuleDefId::TraitAliasId(id) => { - insert_item_loc(db, map, file_id, id, keys::TRAIT_ALIAS) - } - ModuleDefId::AdtId(adt) => match adt { - AdtId::StructId(id) => insert_item_loc(db, map, file_id, id, keys::STRUCT), - AdtId::UnionId(id) => insert_item_loc(db, map, file_id, id, keys::UNION), - AdtId::EnumId(id) => insert_item_loc(db, map, file_id, id, keys::ENUM), - }, - ModuleDefId::MacroId(id) => match id { - MacroId::Macro2Id(id) => insert_item_loc(db, map, file_id, id, keys::MACRO2), - MacroId::MacroRulesId(id) => { - insert_item_loc(db, map, file_id, id, keys::MACRO_RULES) - } - MacroId::ProcMacroId(id) => { - insert_item_loc(db, map, file_id, id, keys::PROC_MACRO) - } - }, - ModuleDefId::ModuleId(_) - | ModuleDefId::EnumVariantId(_) - | ModuleDefId::BuiltinType(_) => (), - } - } - } -} - -impl ChildBySource for VariantId { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, _: HirFileId) { - let arena_map = self.child_source(db); - let arena_map = arena_map.as_ref(); - let parent = *self; - for (local_id, source) in arena_map.value.iter() { - let id = FieldId { parent, local_id }; - match source.clone() { - Either::Left(source) => res[keys::TUPLE_FIELD].insert(AstPtr::new(&source), id), - Either::Right(source) => res[keys::RECORD_FIELD].insert(AstPtr::new(&source), id), - } - } - } -} - -impl ChildBySource for EnumId { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { - let loc = &self.lookup(db); - if file_id != loc.id.file_id() { - return; - } - - let tree = loc.id.item_tree(db); - let ast_id_map = db.ast_id_map(loc.id.file_id()); - - db.enum_data(*self).variants.iter().for_each(|&(variant, _)| { - res[keys::ENUM_VARIANT] - .insert(ast_id_map.get(tree[variant.lookup(db).id.value].ast_id), variant); - }); - } -} - -impl ChildBySource for DefWithBodyId { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { - let (body, sm) = db.body_with_source_map(*self); - if let &DefWithBodyId::VariantId(v) = self { - VariantId::EnumVariantId(v).child_by_source_to(db, res, file_id) - } - - sm.expansions().filter(|(ast, _)| ast.file_id == file_id).for_each(|(ast, &exp_id)| { - res[keys::MACRO_CALL].insert(ast.value, exp_id.macro_call_id); - }); - - for (block, def_map) in body.blocks(db) { - // All block expressions are merged into the same map, because they logically all add - // inner items to the containing `DefWithBodyId`. - def_map[DefMap::ROOT].scope.child_by_source_to(db, res, file_id); - res[keys::BLOCK].insert(block.lookup(db).ast_id.to_ptr(db.upcast()), block); - } - } -} - -impl ChildBySource for GenericDefId { - fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { - let (gfile_id, generic_params_list) = self.file_id_and_params_of(db); - if gfile_id != file_id { - return; - } - - let generic_params = db.generic_params(*self); - let mut toc_idx_iter = generic_params.iter_type_or_consts().map(|(idx, _)| idx); - let lts_idx_iter = generic_params.iter_lt().map(|(idx, _)| idx); - - // For traits the first type index is `Self`, skip it. - if let GenericDefId::TraitId(_) = *self { - toc_idx_iter.next().unwrap(); // advance_by(1); - } - - if let Some(generic_params_list) = generic_params_list { - for (local_id, ast_param) in - toc_idx_iter.zip(generic_params_list.type_or_const_params()) - { - let id = TypeOrConstParamId { parent: *self, local_id }; - match ast_param { - ast::TypeOrConstParam::Type(a) => { - res[keys::TYPE_PARAM].insert(AstPtr::new(&a), id) - } - ast::TypeOrConstParam::Const(a) => { - res[keys::CONST_PARAM].insert(AstPtr::new(&a), id) - } - } - } - for (local_id, ast_param) in lts_idx_iter.zip(generic_params_list.lifetime_params()) { - let id = LifetimeParamId { parent: *self, local_id }; - res[keys::LIFETIME_PARAM].insert(AstPtr::new(&ast_param), id); - } - } - } -} - -fn insert_item_loc( - db: &dyn DefDatabase, - res: &mut DynMap, - file_id: HirFileId, - id: ID, - key: Key, -) where - ID: for<'db> Lookup = dyn DefDatabase + 'db, Data = Data> + 'static, - Data: ItemTreeLoc, - N: ItemTreeNode, - N::Source: 'static, -{ - let loc = id.lookup(db); - if loc.item_tree_id().file_id() == file_id { - res[key].insert(loc.ast_ptr(db).value, id) - } -} - -fn add_assoc_item(db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId, item: AssocItemId) { - match item { - AssocItemId::FunctionId(func) => insert_item_loc(db, res, file_id, func, keys::FUNCTION), - AssocItemId::ConstId(konst) => insert_item_loc(db, res, file_id, konst, keys::CONST), - AssocItemId::TypeAliasId(ty) => insert_item_loc(db, res, file_id, ty, keys::TYPE_ALIAS), - } -} diff --git a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs b/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs index a59bbf7e221..22005695af6 100644 --- a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs +++ b/src/tools/rust-analyzer/crates/hir-def/src/dyn_map.rs @@ -21,7 +21,79 @@ //! //! This is a work of fiction. Any similarities to Kotlin's `BindingContext` are //! a coincidence. -pub mod keys; + +pub mod keys { + use std::marker::PhantomData; + + use hir_expand::{attrs::AttrId, MacroCallId}; + use rustc_hash::FxHashMap; + use syntax::{ast, AstNode, AstPtr}; + + use crate::{ + dyn_map::{DynMap, Policy}, + BlockId, ConstId, EnumId, EnumVariantId, ExternCrateId, FieldId, FunctionId, ImplId, + LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId, TraitAliasId, + TraitId, TypeAliasId, TypeOrConstParamId, UnionId, UseId, + }; + + pub type Key = crate::dyn_map::Key, V, AstPtrPolicy>; + + pub const BLOCK: Key = Key::new(); + pub const FUNCTION: Key = Key::new(); + pub const CONST: Key = Key::new(); + pub const STATIC: Key = Key::new(); + pub const TYPE_ALIAS: Key = Key::new(); + pub const IMPL: Key = Key::new(); + pub const TRAIT: Key = Key::new(); + pub const TRAIT_ALIAS: Key = Key::new(); + pub const STRUCT: Key = Key::new(); + pub const UNION: Key = Key::new(); + pub const ENUM: Key = Key::new(); + pub const EXTERN_CRATE: Key = Key::new(); + pub const USE: Key = Key::new(); + + pub const ENUM_VARIANT: Key = Key::new(); + pub const TUPLE_FIELD: Key = Key::new(); + pub const RECORD_FIELD: Key = Key::new(); + pub const TYPE_PARAM: Key = Key::new(); + pub const CONST_PARAM: Key = Key::new(); + pub const LIFETIME_PARAM: Key = Key::new(); + + pub const MACRO_RULES: Key = Key::new(); + pub const MACRO2: Key = Key::new(); + pub const PROC_MACRO: Key = Key::new(); + pub const MACRO_CALL: Key = Key::new(); + pub const ATTR_MACRO_CALL: Key = Key::new(); + pub const DERIVE_MACRO_CALL: Key]>)> = + Key::new(); + + /// XXX: AST Nodes and SyntaxNodes have identity equality semantics: nodes are + /// equal if they point to exactly the same object. + /// + /// In general, we do not guarantee that we have exactly one instance of a + /// syntax tree for each file. We probably should add such guarantee, but, for + /// the time being, we will use identity-less AstPtr comparison. + pub struct AstPtrPolicy { + _phantom: PhantomData<(AST, ID)>, + } + + impl Policy for AstPtrPolicy { + type K = AstPtr; + type V = ID; + fn insert(map: &mut DynMap, key: AstPtr, value: ID) { + map.map + .entry::, ID>>() + .or_insert_with(Default::default) + .insert(key, value); + } + fn get<'a>(map: &'a DynMap, key: &AstPtr) -> Option<&'a ID> { + map.map.get::, ID>>()?.get(key) + } + fn is_empty(map: &DynMap) -> bool { + map.map.get::, ID>>().map_or(true, |it| it.is_empty()) + } + } +} use std::{ hash::Hash, diff --git a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map/keys.rs b/src/tools/rust-analyzer/crates/hir-def/src/dyn_map/keys.rs deleted file mode 100644 index 9d330a7bf1c..00000000000 --- a/src/tools/rust-analyzer/crates/hir-def/src/dyn_map/keys.rs +++ /dev/null @@ -1,72 +0,0 @@ -//! keys to be used with `DynMap` - -use std::marker::PhantomData; - -use hir_expand::{attrs::AttrId, MacroCallId}; -use rustc_hash::FxHashMap; -use syntax::{ast, AstNode, AstPtr}; - -use crate::{ - dyn_map::{DynMap, Policy}, - BlockId, ConstId, EnumId, EnumVariantId, ExternCrateId, FieldId, FunctionId, ImplId, - LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId, TraitAliasId, - TraitId, TypeAliasId, TypeOrConstParamId, UnionId, UseId, -}; - -pub type Key = crate::dyn_map::Key, V, AstPtrPolicy>; - -pub const BLOCK: Key = Key::new(); -pub const FUNCTION: Key = Key::new(); -pub const CONST: Key = Key::new(); -pub const STATIC: Key = Key::new(); -pub const TYPE_ALIAS: Key = Key::new(); -pub const IMPL: Key = Key::new(); -pub const TRAIT: Key = Key::new(); -pub const TRAIT_ALIAS: Key = Key::new(); -pub const STRUCT: Key = Key::new(); -pub const UNION: Key = Key::new(); -pub const ENUM: Key = Key::new(); -pub const EXTERN_CRATE: Key = Key::new(); -pub const USE: Key = Key::new(); - -pub const ENUM_VARIANT: Key = Key::new(); -pub const TUPLE_FIELD: Key = Key::new(); -pub const RECORD_FIELD: Key = Key::new(); -pub const TYPE_PARAM: Key = Key::new(); -pub const CONST_PARAM: Key = Key::new(); -pub const LIFETIME_PARAM: Key = Key::new(); - -pub const MACRO_RULES: Key = Key::new(); -pub const MACRO2: Key = Key::new(); -pub const PROC_MACRO: Key = Key::new(); -pub const MACRO_CALL: Key = Key::new(); -pub const ATTR_MACRO_CALL: Key = Key::new(); -pub const DERIVE_MACRO_CALL: Key]>)> = - Key::new(); - -/// XXX: AST Nodes and SyntaxNodes have identity equality semantics: nodes are -/// equal if they point to exactly the same object. -/// -/// In general, we do not guarantee that we have exactly one instance of a -/// syntax tree for each file. We probably should add such guarantee, but, for -/// the time being, we will use identity-less AstPtr comparison. -pub struct AstPtrPolicy { - _phantom: PhantomData<(AST, ID)>, -} - -impl Policy for AstPtrPolicy { - type K = AstPtr; - type V = ID; - fn insert(map: &mut DynMap, key: AstPtr, value: ID) { - map.map - .entry::, ID>>() - .or_insert_with(Default::default) - .insert(key, value); - } - fn get<'a>(map: &'a DynMap, key: &AstPtr) -> Option<&'a ID> { - map.map.get::, ID>>()?.get(key) - } - fn is_empty(map: &DynMap) -> bool { - map.map.get::, ID>>().map_or(true, |it| it.is_empty()) - } -} diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs index a04f12cab76..e96e38eceeb 100644 --- a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs +++ b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs @@ -361,9 +361,7 @@ impl ItemScope { self.macro_invocations.get(&call).copied() } - pub(crate) fn iter_macro_invoc( - &self, - ) -> impl Iterator, &MacroCallId)> { + pub fn iter_macro_invoc(&self) -> impl Iterator, &MacroCallId)> { self.macro_invocations.iter() } } @@ -401,9 +399,7 @@ impl ItemScope { self.macro_invocations.insert(call, call_id); } - pub(crate) fn attr_macro_invocs( - &self, - ) -> impl Iterator, MacroCallId)> + '_ { + pub fn attr_macro_invocs(&self) -> impl Iterator, MacroCallId)> + '_ { self.attr_macros.iter().map(|(k, v)| (*k, *v)) } @@ -440,7 +436,7 @@ impl ItemScope { }); } - pub(crate) fn derive_macro_invocs( + pub fn derive_macro_invocs( &self, ) -> impl Iterator< Item = ( diff --git a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs index f6ed826f04c..e73c2ee6f6c 100644 --- a/src/tools/rust-analyzer/crates/hir-def/src/lib.rs +++ b/src/tools/rust-analyzer/crates/hir-def/src/lib.rs @@ -47,7 +47,6 @@ pub mod resolver; pub mod nameres; -pub mod child_by_source; pub mod src; pub mod find_path; @@ -354,9 +353,9 @@ impl_loc!(ProcMacroLoc, id: Function, container: CrateRootModuleId); pub struct BlockId(ra_salsa::InternId); #[derive(Debug, Hash, PartialEq, Eq, Clone)] pub struct BlockLoc { - ast_id: AstId, + pub ast_id: AstId, /// The containing module. - module: ModuleId, + pub module: ModuleId, } impl_intern!(BlockId, BlockLoc, intern_block, lookup_intern_block); @@ -935,7 +934,7 @@ impl_from!( ); impl GenericDefId { - fn file_id_and_params_of( + pub fn file_id_and_params_of( self, db: &dyn DefDatabase, ) -> (HirFileId, Option) { diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics.rs b/src/tools/rust-analyzer/crates/hir/src/semantics.rs index 29c2660554b..9d3f8e5fba4 100644 --- a/src/tools/rust-analyzer/crates/hir/src/semantics.rs +++ b/src/tools/rust-analyzer/crates/hir/src/semantics.rs @@ -1,5 +1,6 @@ //! See `Semantics`. +mod child_by_source; mod source_to_def; use std::{ diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs new file mode 100644 index 00000000000..ec65ea9a9a8 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir/src/semantics/child_by_source.rs @@ -0,0 +1,271 @@ +//! When *constructing* `hir`, we start at some parent syntax node and recursively +//! lower the children. +//! +//! This module allows one to go in the opposite direction: start with a syntax +//! node for a *child*, and get its hir. + +use either::Either; +use hir_expand::{attrs::collect_attrs, HirFileId}; +use syntax::{ast, AstPtr}; + +use hir_def::{ + db::DefDatabase, + dyn_map::{ + keys::{self, Key}, + DynMap, + }, + item_scope::ItemScope, + item_tree::ItemTreeNode, + nameres::DefMap, + src::{HasChildSource, HasSource}, + AdtId, AssocItemId, DefWithBodyId, EnumId, FieldId, GenericDefId, ImplId, ItemTreeLoc, + LifetimeParamId, Lookup, MacroId, ModuleDefId, ModuleId, TraitId, TypeOrConstParamId, + VariantId, +}; + +pub(crate) trait ChildBySource { + fn child_by_source(&self, db: &dyn DefDatabase, file_id: HirFileId) -> DynMap { + let mut res = DynMap::default(); + self.child_by_source_to(db, &mut res, file_id); + res + } + fn child_by_source_to(&self, db: &dyn DefDatabase, map: &mut DynMap, file_id: HirFileId); +} + +impl ChildBySource for TraitId { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { + let data = db.trait_data(*self); + + data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each( + |(ast_id, call_id)| { + res[keys::ATTR_MACRO_CALL].insert(ast_id.to_ptr(db.upcast()), call_id); + }, + ); + data.items.iter().for_each(|&(_, item)| { + add_assoc_item(db, res, file_id, item); + }); + } +} + +impl ChildBySource for ImplId { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { + let data = db.impl_data(*self); + // FIXME: Macro calls + data.attribute_calls().filter(|(ast_id, _)| ast_id.file_id == file_id).for_each( + |(ast_id, call_id)| { + res[keys::ATTR_MACRO_CALL].insert(ast_id.to_ptr(db.upcast()), call_id); + }, + ); + data.items.iter().for_each(|&item| { + add_assoc_item(db, res, file_id, item); + }); + } +} + +impl ChildBySource for ModuleId { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { + let def_map = self.def_map(db); + let module_data = &def_map[self.local_id]; + module_data.scope.child_by_source_to(db, res, file_id); + } +} + +impl ChildBySource for ItemScope { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { + self.declarations().for_each(|item| add_module_def(db, res, file_id, item)); + self.impls().for_each(|imp| insert_item_loc(db, res, file_id, imp, keys::IMPL)); + self.extern_crate_decls() + .for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::EXTERN_CRATE)); + self.use_decls().for_each(|ext| insert_item_loc(db, res, file_id, ext, keys::USE)); + self.unnamed_consts() + .for_each(|konst| insert_item_loc(db, res, file_id, konst, keys::CONST)); + self.attr_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each( + |(ast_id, call_id)| { + res[keys::ATTR_MACRO_CALL].insert(ast_id.to_ptr(db.upcast()), call_id); + }, + ); + self.legacy_macros().for_each(|(_, ids)| { + ids.iter().for_each(|&id| { + if let MacroId::MacroRulesId(id) = id { + let loc = id.lookup(db); + if loc.id.file_id() == file_id { + res[keys::MACRO_RULES].insert(loc.ast_ptr(db).value, id); + } + } + }) + }); + self.derive_macro_invocs().filter(|(id, _)| id.file_id == file_id).for_each( + |(ast_id, calls)| { + let adt = ast_id.to_node(db.upcast()); + calls.for_each(|(attr_id, call_id, calls)| { + if let Some((_, Either::Left(attr))) = + collect_attrs(&adt).nth(attr_id.ast_index()) + { + res[keys::DERIVE_MACRO_CALL] + .insert(AstPtr::new(&attr), (attr_id, call_id, calls.into())); + } + }); + }, + ); + self.iter_macro_invoc().filter(|(id, _)| id.file_id == file_id).for_each( + |(ast_id, &call)| { + let ast = ast_id.to_ptr(db.upcast()); + res[keys::MACRO_CALL].insert(ast, call); + }, + ); + fn add_module_def( + db: &dyn DefDatabase, + map: &mut DynMap, + file_id: HirFileId, + item: ModuleDefId, + ) { + match item { + ModuleDefId::FunctionId(id) => { + insert_item_loc(db, map, file_id, id, keys::FUNCTION) + } + ModuleDefId::ConstId(id) => insert_item_loc(db, map, file_id, id, keys::CONST), + ModuleDefId::TypeAliasId(id) => { + insert_item_loc(db, map, file_id, id, keys::TYPE_ALIAS) + } + ModuleDefId::StaticId(id) => insert_item_loc(db, map, file_id, id, keys::STATIC), + ModuleDefId::TraitId(id) => insert_item_loc(db, map, file_id, id, keys::TRAIT), + ModuleDefId::TraitAliasId(id) => { + insert_item_loc(db, map, file_id, id, keys::TRAIT_ALIAS) + } + ModuleDefId::AdtId(adt) => match adt { + AdtId::StructId(id) => insert_item_loc(db, map, file_id, id, keys::STRUCT), + AdtId::UnionId(id) => insert_item_loc(db, map, file_id, id, keys::UNION), + AdtId::EnumId(id) => insert_item_loc(db, map, file_id, id, keys::ENUM), + }, + ModuleDefId::MacroId(id) => match id { + MacroId::Macro2Id(id) => insert_item_loc(db, map, file_id, id, keys::MACRO2), + MacroId::MacroRulesId(id) => { + insert_item_loc(db, map, file_id, id, keys::MACRO_RULES) + } + MacroId::ProcMacroId(id) => { + insert_item_loc(db, map, file_id, id, keys::PROC_MACRO) + } + }, + ModuleDefId::ModuleId(_) + | ModuleDefId::EnumVariantId(_) + | ModuleDefId::BuiltinType(_) => (), + } + } + } +} + +impl ChildBySource for VariantId { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, _: HirFileId) { + let arena_map = self.child_source(db); + let arena_map = arena_map.as_ref(); + let parent = *self; + for (local_id, source) in arena_map.value.iter() { + let id = FieldId { parent, local_id }; + match source.clone() { + Either::Left(source) => res[keys::TUPLE_FIELD].insert(AstPtr::new(&source), id), + Either::Right(source) => res[keys::RECORD_FIELD].insert(AstPtr::new(&source), id), + } + } + } +} + +impl ChildBySource for EnumId { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { + let loc = &self.lookup(db); + if file_id != loc.id.file_id() { + return; + } + + let tree = loc.id.item_tree(db); + let ast_id_map = db.ast_id_map(loc.id.file_id()); + + db.enum_data(*self).variants.iter().for_each(|&(variant, _)| { + res[keys::ENUM_VARIANT] + .insert(ast_id_map.get(tree[variant.lookup(db).id.value].ast_id), variant); + }); + } +} + +impl ChildBySource for DefWithBodyId { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { + let (body, sm) = db.body_with_source_map(*self); + if let &DefWithBodyId::VariantId(v) = self { + VariantId::EnumVariantId(v).child_by_source_to(db, res, file_id) + } + + sm.expansions().filter(|(ast, _)| ast.file_id == file_id).for_each(|(ast, &exp_id)| { + res[keys::MACRO_CALL].insert(ast.value, exp_id.macro_call_id); + }); + + for (block, def_map) in body.blocks(db) { + // All block expressions are merged into the same map, because they logically all add + // inner items to the containing `DefWithBodyId`. + def_map[DefMap::ROOT].scope.child_by_source_to(db, res, file_id); + res[keys::BLOCK].insert(block.lookup(db).ast_id.to_ptr(db.upcast()), block); + } + } +} + +impl ChildBySource for GenericDefId { + fn child_by_source_to(&self, db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId) { + let (gfile_id, generic_params_list) = self.file_id_and_params_of(db); + if gfile_id != file_id { + return; + } + + let generic_params = db.generic_params(*self); + let mut toc_idx_iter = generic_params.iter_type_or_consts().map(|(idx, _)| idx); + let lts_idx_iter = generic_params.iter_lt().map(|(idx, _)| idx); + + // For traits the first type index is `Self`, skip it. + if let GenericDefId::TraitId(_) = *self { + toc_idx_iter.next().unwrap(); // advance_by(1); + } + + if let Some(generic_params_list) = generic_params_list { + for (local_id, ast_param) in + toc_idx_iter.zip(generic_params_list.type_or_const_params()) + { + let id = TypeOrConstParamId { parent: *self, local_id }; + match ast_param { + ast::TypeOrConstParam::Type(a) => { + res[keys::TYPE_PARAM].insert(AstPtr::new(&a), id) + } + ast::TypeOrConstParam::Const(a) => { + res[keys::CONST_PARAM].insert(AstPtr::new(&a), id) + } + } + } + for (local_id, ast_param) in lts_idx_iter.zip(generic_params_list.lifetime_params()) { + let id = LifetimeParamId { parent: *self, local_id }; + res[keys::LIFETIME_PARAM].insert(AstPtr::new(&ast_param), id); + } + } + } +} + +fn insert_item_loc( + db: &dyn DefDatabase, + res: &mut DynMap, + file_id: HirFileId, + id: ID, + key: Key, +) where + ID: for<'db> Lookup = dyn DefDatabase + 'db, Data = Data> + 'static, + Data: ItemTreeLoc, + N: ItemTreeNode, + N::Source: 'static, +{ + let loc = id.lookup(db); + if loc.item_tree_id().file_id() == file_id { + res[key].insert(loc.ast_ptr(db).value, id) + } +} + +fn add_assoc_item(db: &dyn DefDatabase, res: &mut DynMap, file_id: HirFileId, item: AssocItemId) { + match item { + AssocItemId::FunctionId(func) => insert_item_loc(db, res, file_id, func, keys::FUNCTION), + AssocItemId::ConstId(konst) => insert_item_loc(db, res, file_id, konst, keys::CONST), + AssocItemId::TypeAliasId(ty) => insert_item_loc(db, res, file_id, ty, keys::TYPE_ALIAS), + } +} diff --git a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs index 5357e824d09..08333c2d76c 100644 --- a/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs +++ b/src/tools/rust-analyzer/crates/hir/src/semantics/source_to_def.rs @@ -87,7 +87,6 @@ use either::Either; use hir_def::{ - child_by_source::ChildBySource, dyn_map::{ keys::{self, Key}, DynMap, @@ -111,7 +110,10 @@ use syntax::{ AstNode, AstPtr, SyntaxNode, }; -use crate::{db::HirDatabase, InFile, InlineAsmOperand, SemanticsImpl}; +use crate::{ + db::HirDatabase, semantics::child_by_source::ChildBySource, InFile, InlineAsmOperand, + SemanticsImpl, +}; #[derive(Default)] pub(super) struct SourceToDefCache { diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs index f01b4ea0fd4..83f4a6b123c 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_tuple_struct_to_named_struct.rs @@ -104,7 +104,7 @@ fn edit_struct_def( ast::make::tokens::single_newline().text(), ); edit.insert(tuple_fields_text_range.start(), w.syntax().text()); - if !w.syntax().last_token().is_some_and(|t| t.kind() == SyntaxKind::COMMA) { + if w.syntax().last_token().is_none_or(|t| t.kind() != SyntaxKind::COMMA) { edit.insert(tuple_fields_text_range.start(), ","); } edit.insert( diff --git a/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs b/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs index 45c723d09d4..1f1b6478d36 100644 --- a/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs +++ b/src/tools/rust-analyzer/crates/ide-diagnostics/src/lib.rs @@ -382,7 +382,7 @@ pub fn semantic_diagnostics( // A bunch of parse errors in a file indicate some bigger structural parse changes in the // file, so we skip semantic diagnostics so we can show these faster. Some(m) => { - if !db.parse_errors(file_id).as_deref().is_some_and(|es| es.len() >= 16) { + if db.parse_errors(file_id).as_deref().is_none_or(|es| es.len() < 16) { m.diagnostics(db, &mut diags, config.style_lints); } } -- cgit 1.4.1-3-g733a5