crates/ide_db/src/helpers/famous_defs.rs

   1 //! See [`FamousDefs`].
   2 use hir::{Crate, Enum, MacroDef, Module, ScopeDef, Semantics, Trait};
   3
   4 use crate::RootDatabase;
   5
   6 /// Helps with finding well-know things inside the standard library. This is
   7 /// somewhat similar to the known paths infra inside hir, but it different; We
   8 /// want to make sure that IDE specific paths don't become interesting inside
   9 /// the compiler itself as well.
  10 ///
  11 /// Note that, by default, rust-analyzer tests **do not** include core or std
  12 /// libraries. If you are writing tests for functionality using [`FamousDefs`],
  13 /// you'd want to include minicore (see `test_utils::MiniCore`) declaration at
  14 /// the start of your tests:
  15 ///
  16 /// ```
  17 /// //- minicore: iterator, ord, derive
  18 /// ```
  19 pub struct FamousDefs<'a, 'b>(pub &'a Semantics<'b, RootDatabase>, pub Option<Crate>);
  20
  21 #[allow(non_snake_case)]
  22 impl FamousDefs<'_, '_> {
  23     pub fn std(&self) -> Option<Crate> {
  24         self.find_crate("std")
  25     }
  26
  27     pub fn core(&self) -> Option<Crate> {
  28         self.find_crate("core")
  29     }
  30
  31     pub fn core_cmp_Ord(&self) -> Option<Trait> {
  32         self.find_trait("core:cmp:Ord")
  33     }
  34
  35     pub fn core_convert_From(&self) -> Option<Trait> {
  36         self.find_trait("core:convert:From")
  37     }
  38
  39     pub fn core_convert_Into(&self) -> Option<Trait> {
  40         self.find_trait("core:convert:Into")
  41     }
  42
  43     pub fn core_option_Option(&self) -> Option<Enum> {
  44         self.find_enum("core:option:Option")
  45     }
  46
  47     pub fn core_result_Result(&self) -> Option<Enum> {
  48         self.find_enum("core:result:Result")
  49     }
  50
  51     pub fn core_default_Default(&self) -> Option<Trait> {
  52         self.find_trait("core:default:Default")
  53     }
  54
  55     pub fn core_iter_Iterator(&self) -> Option<Trait> {
  56         self.find_trait("core:iter:traits:iterator:Iterator")
  57     }
  58
  59     pub fn core_iter_IntoIterator(&self) -> Option<Trait> {
  60         self.find_trait("core:iter:traits:collect:IntoIterator")
  61     }
  62
  63     pub fn core_iter(&self) -> Option<Module> {
  64         self.find_module("core:iter")
  65     }
  66
  67     pub fn core_ops_Deref(&self) -> Option<Trait> {
  68         self.find_trait("core:ops:Deref")
  69     }
  70
  71     pub fn core_convert_AsRef(&self) -> Option<Trait> {
  72         self.find_trait("core:convert:AsRef")
  73     }
  74
  75     pub fn core_ops_ControlFlow(&self) -> Option<Enum> {
  76         self.find_enum("core:ops:ControlFlow")
  77     }
  78
  79     pub fn core_marker_Copy(&self) -> Option<Trait> {
  80         self.find_trait("core:marker:Copy")
  81     }
  82
  83     pub fn core_macros_builtin_derive(&self) -> Option<MacroDef> {
  84         self.find_macro("core:macros:builtin:derive")
  85     }
  86
  87     pub fn alloc(&self) -> Option<Crate> {
  88         self.find_crate("alloc")
  89     }
  90
  91     pub fn test(&self) -> Option<Crate> {
  92         self.find_crate("test")
  93     }
  94
  95     pub fn proc_macro(&self) -> Option<Crate> {
  96         self.find_crate("proc_macro")
  97     }
  98
  99     pub fn builtin_crates(&self) -> impl Iterator<Item = Crate> {
 100         IntoIterator::into_iter([
 101             self.std(),
 102             self.core(),
 103             self.alloc(),
 104             self.test(),
 105             self.proc_macro(),
 106         ])
 107         .filter_map(|it| it)
 108     }
 109
 110     fn find_trait(&self, path: &str) -> Option<Trait> {
 111         match self.find_def(path)? {
 112             hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
 113             _ => None,
 114         }
 115     }
 116
 117     fn find_macro(&self, path: &str) -> Option<MacroDef> {
 118         match self.find_def(path)? {
 119             hir::ScopeDef::MacroDef(it) => Some(it),
 120             _ => None,
 121         }
 122     }
 123
 124     fn find_enum(&self, path: &str) -> Option<Enum> {
 125         match self.find_def(path)? {
 126             hir::ScopeDef::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(it))) => Some(it),
 127             _ => None,
 128         }
 129     }
 130
 131     fn find_module(&self, path: &str) -> Option<Module> {
 132         match self.find_def(path)? {
 133             hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(it)) => Some(it),
 134             _ => None,
 135         }
 136     }
 137
 138     fn find_crate(&self, name: &str) -> Option<Crate> {
 139         let krate = self.1?;
 140         let db = self.0.db;
 141         let res =
 142             krate.dependencies(db).into_iter().find(|dep| dep.name.to_string() == name)?.krate;
 143         Some(res)
 144     }
 145
 146     fn find_def(&self, path: &str) -> Option<ScopeDef> {
 147         let db = self.0.db;
 148         let mut path = path.split(':');
 149         let trait_ = path.next_back()?;
 150         let std_crate = path.next()?;
 151         let std_crate = self.find_crate(std_crate)?;
 152         let mut module = std_crate.root_module(db);
 153         for segment in path {
 154             module = module.children(db).find_map(|child| {
 155                 let name = child.name(db)?;
 156                 if name.to_string() == segment {
 157                     Some(child)
 158                 } else {
 159                     None
 160                 }
 161             })?;
 162         }
 163         let def =
 164             module.scope(db, None).into_iter().find(|(name, _def)| name.to_string() == trait_)?.1;
 165         Some(def)
 166     }
 167 }