crates/ide_db/src/helpers/famous_defs.rs

   1 //! See [`FamousDefs`].
   2 use hir::{Crate, Enum, 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_ops_ControlFlow(&self) -> Option<Enum> {
  72         self.find_enum("core:ops:ControlFlow")
  73     }
  74
  75     pub fn alloc(&self) -> Option<Crate> {
  76         self.find_crate("alloc")
  77     }
  78
  79     pub fn test(&self) -> Option<Crate> {
  80         self.find_crate("test")
  81     }
  82
  83     pub fn proc_macro(&self) -> Option<Crate> {
  84         self.find_crate("proc_macro")
  85     }
  86
  87     pub fn builtin_crates(&self) -> impl Iterator<Item = Crate> {
  88         IntoIterator::into_iter([
  89             self.std(),
  90             self.core(),
  91             self.alloc(),
  92             self.test(),
  93             self.proc_macro(),
  94         ])
  95         .filter_map(|it| it)
  96     }
  97
  98     fn find_trait(&self, path: &str) -> Option<Trait> {
  99         match self.find_def(path)? {
 100             hir::ScopeDef::ModuleDef(hir::ModuleDef::Trait(it)) => Some(it),
 101             _ => None,
 102         }
 103     }
 104
 105     fn find_enum(&self, path: &str) -> Option<Enum> {
 106         match self.find_def(path)? {
 107             hir::ScopeDef::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Enum(it))) => Some(it),
 108             _ => None,
 109         }
 110     }
 111
 112     fn find_module(&self, path: &str) -> Option<Module> {
 113         match self.find_def(path)? {
 114             hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(it)) => Some(it),
 115             _ => None,
 116         }
 117     }
 118
 119     fn find_crate(&self, name: &str) -> Option<Crate> {
 120         let krate = self.1?;
 121         let db = self.0.db;
 122         let res =
 123             krate.dependencies(db).into_iter().find(|dep| dep.name.to_string() == name)?.krate;
 124         Some(res)
 125     }
 126
 127     fn find_def(&self, path: &str) -> Option<ScopeDef> {
 128         let db = self.0.db;
 129         let mut path = path.split(':');
 130         let trait_ = path.next_back()?;
 131         let std_crate = path.next()?;
 132         let std_crate = self.find_crate(std_crate)?;
 133         let mut module = std_crate.root_module(db);
 134         for segment in path {
 135             module = module.children(db).find_map(|child| {
 136                 let name = child.name(db)?;
 137                 if name.to_string() == segment {
 138                     Some(child)
 139                 } else {
 140                     None
 141                 }
 142             })?;
 143         }
 144         let def =
 145             module.scope(db, None).into_iter().find(|(name, _def)| name.to_string() == trait_)?.1;
 146         Some(def)
 147     }
 148 }