crates/ra_hir_def/src/lang_item.rs

   1 //! Collects lang items: items marked with `#[lang = "..."]` attribute.
   2 //!
   3 //! This attribute to tell the compiler about semi built-in std library
   4 //! features, such as Fn family of traits.
   5 use std::sync::Arc;
   6
   7 use ra_prof::profile;
   8 use ra_syntax::SmolStr;
   9 use rustc_hash::FxHashMap;
  10
  11 use crate::{
  12     db::DefDatabase, AdtId, AttrDefId, CrateId, EnumId, FunctionId, ImplId, ModuleDefId, ModuleId,
  13     StaticId, StructId, TraitId,
  14 };
  15
  16 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  17 pub enum LangItemTarget {
  18     EnumId(EnumId),
  19     FunctionId(FunctionId),
  20     ImplDefId(ImplId),
  21     StaticId(StaticId),
  22     StructId(StructId),
  23     TraitId(TraitId),
  24 }
  25
  26 impl LangItemTarget {
  27     pub fn as_enum(self) -> Option<EnumId> {
  28         match self {
  29             LangItemTarget::EnumId(id) => Some(id),
  30             _ => None,
  31         }
  32     }
  33
  34     pub fn as_function(self) -> Option<FunctionId> {
  35         match self {
  36             LangItemTarget::FunctionId(id) => Some(id),
  37             _ => None,
  38         }
  39     }
  40
  41     pub fn as_impl_def(self) -> Option<ImplId> {
  42         match self {
  43             LangItemTarget::ImplDefId(id) => Some(id),
  44             _ => None,
  45         }
  46     }
  47
  48     pub fn as_static(self) -> Option<StaticId> {
  49         match self {
  50             LangItemTarget::StaticId(id) => Some(id),
  51             _ => None,
  52         }
  53     }
  54
  55     pub fn as_struct(self) -> Option<StructId> {
  56         match self {
  57             LangItemTarget::StructId(id) => Some(id),
  58             _ => None,
  59         }
  60     }
  61
  62     pub fn as_trait(self) -> Option<TraitId> {
  63         match self {
  64             LangItemTarget::TraitId(id) => Some(id),
  65             _ => None,
  66         }
  67     }
  68 }
  69
  70 #[derive(Default, Debug, Clone, PartialEq, Eq)]
  71 pub struct LangItems {
  72     items: FxHashMap<SmolStr, LangItemTarget>,
  73 }
  74
  75 impl LangItems {
  76     pub fn target(&self, item: &str) -> Option<LangItemTarget> {
  77         self.items.get(item).copied()
  78     }
  79
  80     /// Salsa query. This will look for lang items in a specific crate.
  81     pub(crate) fn crate_lang_items_query(db: &dyn DefDatabase, krate: CrateId) -> Arc<LangItems> {
  82         let _p = profile("crate_lang_items_query");
  83
  84         let mut lang_items = LangItems::default();
  85
  86         let crate_def_map = db.crate_def_map(krate);
  87
  88         crate_def_map
  89             .modules
  90             .iter()
  91             .filter_map(|(local_id, _)| db.module_lang_items(ModuleId { krate, local_id }))
  92             .for_each(|it| lang_items.items.extend(it.items.iter().map(|(k, v)| (k.clone(), *v))));
  93
  94         Arc::new(lang_items)
  95     }
  96
  97     pub(crate) fn module_lang_items_query(
  98         db: &dyn DefDatabase,
  99         module: ModuleId,
 100     ) -> Option<Arc<LangItems>> {
 101         let _p = profile("module_lang_items_query");
 102         let mut lang_items = LangItems::default();
 103         lang_items.collect_lang_items(db, module);
 104         if lang_items.items.is_empty() {
 105             None
 106         } else {
 107             Some(Arc::new(lang_items))
 108         }
 109     }
 110
 111     /// Salsa query. Look for a lang item, starting from the specified crate and recursively
 112     /// traversing its dependencies.
 113     pub(crate) fn lang_item_query(
 114         db: &dyn DefDatabase,
 115         start_crate: CrateId,
 116         item: SmolStr,
 117     ) -> Option<LangItemTarget> {
 118         let _p = profile("lang_item_query");
 119         let lang_items = db.crate_lang_items(start_crate);
 120         let start_crate_target = lang_items.items.get(&item);
 121         if let Some(target) = start_crate_target {
 122             return Some(*target);
 123         }
 124         db.crate_graph()[start_crate]
 125             .dependencies
 126             .iter()
 127             .find_map(|dep| db.lang_item(dep.crate_id, item.clone()))
 128     }
 129
 130     fn collect_lang_items(&mut self, db: &dyn DefDatabase, module: ModuleId) {
 131         // Look for impl targets
 132         let def_map = db.crate_def_map(module.krate);
 133         let module_data = &def_map[module.local_id];
 134         for impl_def in module_data.scope.impls() {
 135             self.collect_lang_item(db, impl_def, LangItemTarget::ImplDefId)
 136         }
 137
 138         for def in module_data.scope.declarations() {
 139             match def {
 140                 ModuleDefId::TraitId(trait_) => {
 141                     self.collect_lang_item(db, trait_, LangItemTarget::TraitId)
 142                 }
 143                 ModuleDefId::AdtId(AdtId::EnumId(e)) => {
 144                     self.collect_lang_item(db, e, LangItemTarget::EnumId)
 145                 }
 146                 ModuleDefId::AdtId(AdtId::StructId(s)) => {
 147                     self.collect_lang_item(db, s, LangItemTarget::StructId)
 148                 }
 149                 ModuleDefId::FunctionId(f) => {
 150                     self.collect_lang_item(db, f, LangItemTarget::FunctionId)
 151                 }
 152                 ModuleDefId::StaticId(s) => self.collect_lang_item(db, s, LangItemTarget::StaticId),
 153                 _ => {}
 154             }
 155         }
 156     }
 157
 158     fn collect_lang_item<T>(
 159         &mut self,
 160         db: &dyn DefDatabase,
 161         item: T,
 162         constructor: fn(T) -> LangItemTarget,
 163     ) where
 164         T: Into<AttrDefId> + Copy,
 165     {
 166         if let Some(lang_item_name) = lang_attr(db, item) {
 167             self.items.entry(lang_item_name.clone()).or_insert_with(|| constructor(item));
 168         }
 169     }
 170 }
 171
 172 pub fn lang_attr(db: &dyn DefDatabase, item: impl Into<AttrDefId> + Copy) -> Option<SmolStr> {
 173     let attrs = db.attrs(item.into());
 174     attrs.by_key("lang").string_value().cloned()
 175 }