From 1a9986496387544c048475765ac64e83518437af Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 23 Nov 2019 12:01:56 +0300 Subject: Use attrs rather than syntax for lang items --- crates/ra_hir/src/lang_item.rs | 56 +++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 31 deletions(-) (limited to 'crates/ra_hir/src/lang_item.rs') diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs index 89fd85f59..55f0c3a13 100644 --- a/crates/ra_hir/src/lang_item.rs +++ b/crates/ra_hir/src/lang_item.rs @@ -1,13 +1,14 @@ //! FIXME: write short doc here -use rustc_hash::FxHashMap; use std::sync::Arc; -use ra_syntax::{ast::AttrsOwner, SmolStr}; +use hir_def::{AdtId, AttrDefId, ModuleDefId}; +use ra_syntax::SmolStr; +use rustc_hash::FxHashMap; use crate::{ db::{AstDatabase, DefDatabase, HirDatabase}, - Adt, Crate, Enum, Function, HasSource, ImplBlock, Module, ModuleDef, Static, Struct, Trait, + Crate, Enum, Function, ImplBlock, Module, Static, Struct, Trait, }; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] @@ -95,26 +96,27 @@ impl LangItems { fn collect_lang_items(&mut self, db: &(impl DefDatabase + AstDatabase), module: Module) { // Look for impl targets - for impl_block in module.impl_blocks(db) { - let src = impl_block.source(db); - if let Some(lang_item_name) = lang_item_name(&src.value) { - self.items - .entry(lang_item_name) - .or_insert_with(|| LangItemTarget::ImplBlock(impl_block)); - } + let def_map = db.crate_def_map(module.id.krate); + let module_data = &def_map[module.id.module_id]; + for &impl_block in module_data.impls.iter() { + self.collect_lang_item(db, impl_block, LangItemTarget::ImplBlock) } - for def in module.declarations(db) { + for def in module_data.scope.declarations() { match def { - ModuleDef::Trait(trait_) => { + ModuleDefId::TraitId(trait_) => { self.collect_lang_item(db, trait_, LangItemTarget::Trait) } - ModuleDef::Adt(Adt::Enum(e)) => self.collect_lang_item(db, e, LangItemTarget::Enum), - ModuleDef::Adt(Adt::Struct(s)) => { + ModuleDefId::AdtId(AdtId::EnumId(e)) => { + self.collect_lang_item(db, e, LangItemTarget::Enum) + } + ModuleDefId::AdtId(AdtId::StructId(s)) => { self.collect_lang_item(db, s, LangItemTarget::Struct) } - ModuleDef::Function(f) => self.collect_lang_item(db, f, LangItemTarget::Function), - ModuleDef::Static(s) => self.collect_lang_item(db, s, LangItemTarget::Static), + ModuleDefId::FunctionId(f) => { + self.collect_lang_item(db, f, LangItemTarget::Function) + } + ModuleDefId::StaticId(s) => self.collect_lang_item(db, s, LangItemTarget::Static), _ => {} } } @@ -135,26 +137,18 @@ impl LangItems { } } - fn collect_lang_item( + fn collect_lang_item( &mut self, db: &(impl DefDatabase + AstDatabase), item: T, - constructor: fn(T) -> LangItemTarget, + constructor: fn(D) -> LangItemTarget, ) where - T: Copy + HasSource, - N: AttrsOwner, + T: Into + Copy, + D: From, { - let node = item.source(db).value; - if let Some(lang_item_name) = lang_item_name(&node) { - self.items.entry(lang_item_name).or_insert_with(|| constructor(item)); + let attrs = db.attrs(item.into()); + if let Some(lang_item_name) = attrs.find_string_value("lang") { + self.items.entry(lang_item_name).or_insert_with(|| constructor(D::from(item))); } } } - -fn lang_item_name(node: &T) -> Option { - node.attrs() - .filter_map(|a| a.as_simple_key_value()) - .filter(|(key, _)| key == "lang") - .map(|(_, val)| val) - .nth(0) -} -- cgit v1.2.3 From 8692977d2798831d0aea434277ee54d589aa9be3 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 23 Nov 2019 12:58:01 +0300 Subject: Move lang_items to hir_def --- crates/ra_hir/src/lang_item.rs | 154 ----------------------------------------- 1 file changed, 154 deletions(-) delete mode 100644 crates/ra_hir/src/lang_item.rs (limited to 'crates/ra_hir/src/lang_item.rs') diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs deleted file mode 100644 index 55f0c3a13..000000000 --- a/crates/ra_hir/src/lang_item.rs +++ /dev/null @@ -1,154 +0,0 @@ -//! FIXME: write short doc here - -use std::sync::Arc; - -use hir_def::{AdtId, AttrDefId, ModuleDefId}; -use ra_syntax::SmolStr; -use rustc_hash::FxHashMap; - -use crate::{ - db::{AstDatabase, DefDatabase, HirDatabase}, - Crate, Enum, Function, ImplBlock, Module, Static, Struct, Trait, -}; - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub enum LangItemTarget { - Enum(Enum), - Function(Function), - ImplBlock(ImplBlock), - Static(Static), - Struct(Struct), - Trait(Trait), -} - -impl LangItemTarget { - pub(crate) fn krate(&self, db: &impl HirDatabase) -> Option { - Some(match self { - LangItemTarget::Enum(e) => e.module(db).krate(), - LangItemTarget::Function(f) => f.module(db).krate(), - LangItemTarget::ImplBlock(i) => i.krate(db), - LangItemTarget::Static(s) => s.module(db).krate(), - LangItemTarget::Struct(s) => s.module(db).krate(), - LangItemTarget::Trait(t) => t.module(db).krate(), - }) - } -} - -#[derive(Default, Debug, Clone, PartialEq, Eq)] -pub struct LangItems { - items: FxHashMap, -} - -impl LangItems { - pub fn target<'a>(&'a self, item: &str) -> Option<&'a LangItemTarget> { - self.items.get(item) - } - - /// Salsa query. This will look for lang items in a specific crate. - pub(crate) fn crate_lang_items_query( - db: &(impl DefDatabase + AstDatabase), - krate: Crate, - ) -> Arc { - let mut lang_items = LangItems::default(); - - if let Some(module) = krate.root_module(db) { - lang_items.collect_lang_items_recursive(db, module); - } - - Arc::new(lang_items) - } - - pub(crate) fn module_lang_items_query( - db: &(impl DefDatabase + AstDatabase), - module: Module, - ) -> Option> { - let mut lang_items = LangItems::default(); - lang_items.collect_lang_items(db, module); - if lang_items.items.is_empty() { - None - } else { - Some(Arc::new(lang_items)) - } - } - - /// Salsa query. Look for a lang item, starting from the specified crate and recursively - /// traversing its dependencies. - pub(crate) fn lang_item_query( - db: &impl DefDatabase, - start_crate: Crate, - item: SmolStr, - ) -> Option { - let lang_items = db.crate_lang_items(start_crate); - let start_crate_target = lang_items.items.get(&item); - if let Some(target) = start_crate_target { - Some(*target) - } else { - for dep in start_crate.dependencies(db) { - let dep_crate = dep.krate; - let dep_target = db.lang_item(dep_crate, item.clone()); - if dep_target.is_some() { - return dep_target; - } - } - None - } - } - - fn collect_lang_items(&mut self, db: &(impl DefDatabase + AstDatabase), module: Module) { - // Look for impl targets - let def_map = db.crate_def_map(module.id.krate); - let module_data = &def_map[module.id.module_id]; - for &impl_block in module_data.impls.iter() { - self.collect_lang_item(db, impl_block, LangItemTarget::ImplBlock) - } - - for def in module_data.scope.declarations() { - match def { - ModuleDefId::TraitId(trait_) => { - self.collect_lang_item(db, trait_, LangItemTarget::Trait) - } - ModuleDefId::AdtId(AdtId::EnumId(e)) => { - self.collect_lang_item(db, e, LangItemTarget::Enum) - } - ModuleDefId::AdtId(AdtId::StructId(s)) => { - self.collect_lang_item(db, s, LangItemTarget::Struct) - } - ModuleDefId::FunctionId(f) => { - self.collect_lang_item(db, f, LangItemTarget::Function) - } - ModuleDefId::StaticId(s) => self.collect_lang_item(db, s, LangItemTarget::Static), - _ => {} - } - } - } - - fn collect_lang_items_recursive( - &mut self, - db: &(impl DefDatabase + AstDatabase), - module: Module, - ) { - if let Some(module_lang_items) = db.module_lang_items(module) { - self.items.extend(module_lang_items.items.iter().map(|(k, v)| (k.clone(), *v))) - } - - // Look for lang items in the children - for child in module.children(db) { - self.collect_lang_items_recursive(db, child); - } - } - - fn collect_lang_item( - &mut self, - db: &(impl DefDatabase + AstDatabase), - item: T, - constructor: fn(D) -> LangItemTarget, - ) where - T: Into + Copy, - D: From, - { - let attrs = db.attrs(item.into()); - if let Some(lang_item_name) = attrs.find_string_value("lang") { - self.items.entry(lang_item_name).or_insert_with(|| constructor(D::from(item))); - } - } -} -- cgit v1.2.3