crates/hir_def/src/resolver.rs

   1 //! Name resolution façade.
   2 use std::sync::Arc;
   3
   4 use base_db::CrateId;
   5 use hir_expand::{
   6     name::{name, Name},
   7     MacroDefId,
   8 };
   9 use rustc_hash::FxHashSet;
  10
  11 use crate::{
  12     body::scope::{ExprScopes, ScopeId},
  13     builtin_type::BuiltinType,
  14     db::DefDatabase,
  15     expr::{ExprId, LabelId, PatId},
  16     generics::GenericParams,
  17     intern::Interned,
  18     item_scope::{BuiltinShadowMode, BUILTIN_SCOPE},
  19     nameres::DefMap,
  20     path::{ModPath, PathKind},
  21     per_ns::PerNs,
  22     visibility::{RawVisibility, Visibility},
  23     AdtId, AssocContainerId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
  24     FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, LifetimeParamId, LocalModuleId,
  25     Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId,
  26     VariantId,
  27 };
  28
  29 #[derive(Debug, Clone, Default)]
  30 pub struct Resolver {
  31     // FIXME: all usages generally call `.rev`, so maybe reverse once in construction?
  32     scopes: Vec<Scope>,
  33 }
  34
  35 // FIXME how to store these best
  36 #[derive(Debug, Clone)]
  37 struct ModuleItemMap {
  38     def_map: Arc<DefMap>,
  39     module_id: LocalModuleId,
  40 }
  41
  42 #[derive(Debug, Clone)]
  43 struct ExprScope {
  44     owner: DefWithBodyId,
  45     expr_scopes: Arc<ExprScopes>,
  46     scope_id: ScopeId,
  47 }
  48
  49 #[derive(Debug, Clone)]
  50 enum Scope {
  51     /// All the items and imported names of a module
  52     ModuleScope(ModuleItemMap),
  53     /// Brings the generic parameters of an item into scope
  54     GenericParams { def: GenericDefId, params: Interned<GenericParams> },
  55     /// Brings `Self` in `impl` block into scope
  56     ImplDefScope(ImplId),
  57     /// Brings `Self` in enum, struct and union definitions into scope
  58     AdtScope(AdtId),
  59     /// Local bindings
  60     ExprScope(ExprScope),
  61 }
  62
  63 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  64 pub enum TypeNs {
  65     SelfType(ImplId),
  66     GenericParam(TypeParamId),
  67     AdtId(AdtId),
  68     AdtSelfType(AdtId),
  69     // Yup, enum variants are added to the types ns, but any usage of variant as
  70     // type is an error.
  71     EnumVariantId(EnumVariantId),
  72     TypeAliasId(TypeAliasId),
  73     BuiltinType(BuiltinType),
  74     TraitId(TraitId),
  75     // Module belong to type ns, but the resolver is used when all module paths
  76     // are fully resolved.
  77     // ModuleId(ModuleId)
  78 }
  79
  80 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  81 pub enum ResolveValueResult {
  82     ValueNs(ValueNs),
  83     Partial(TypeNs, usize),
  84 }
  85
  86 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  87 pub enum ValueNs {
  88     ImplSelf(ImplId),
  89     LocalBinding(PatId),
  90     FunctionId(FunctionId),
  91     ConstId(ConstId),
  92     StaticId(StaticId),
  93     StructId(StructId),
  94     EnumVariantId(EnumVariantId),
  95     GenericParam(ConstParamId),
  96 }
  97
  98 impl Resolver {
  99     /// Resolve known trait from std, like `std::futures::Future`
 100     pub fn resolve_known_trait(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<TraitId> {
 101         let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
 102         match res {
 103             ModuleDefId::TraitId(it) => Some(it),
 104             _ => None,
 105         }
 106     }
 107
 108     /// Resolve known struct from std, like `std::boxed::Box`
 109     pub fn resolve_known_struct(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<StructId> {
 110         let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
 111         match res {
 112             ModuleDefId::AdtId(AdtId::StructId(it)) => Some(it),
 113             _ => None,
 114         }
 115     }
 116
 117     /// Resolve known enum from std, like `std::result::Result`
 118     pub fn resolve_known_enum(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<EnumId> {
 119         let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
 120         match res {
 121             ModuleDefId::AdtId(AdtId::EnumId(it)) => Some(it),
 122             _ => None,
 123         }
 124     }
 125
 126     fn resolve_module_path(
 127         &self,
 128         db: &dyn DefDatabase,
 129         path: &ModPath,
 130         shadow: BuiltinShadowMode,
 131     ) -> PerNs {
 132         let (item_map, module) = match self.module_scope() {
 133             Some(it) => it,
 134             None => return PerNs::none(),
 135         };
 136         let (module_res, segment_index) = item_map.resolve_path(db, module, &path, shadow);
 137         if segment_index.is_some() {
 138             return PerNs::none();
 139         }
 140         module_res
 141     }
 142
 143     pub fn resolve_module_path_in_items(&self, db: &dyn DefDatabase, path: &ModPath) -> PerNs {
 144         self.resolve_module_path(db, path, BuiltinShadowMode::Module)
 145     }
 146
 147     pub fn resolve_module_path_in_trait_items(
 148         &self,
 149         db: &dyn DefDatabase,
 150         path: &ModPath,
 151     ) -> Option<TraitId> {
 152         let (item_map, module) = self.module_scope()?;
 153         let (module_res, ..) = item_map.resolve_path(db, module, &path, BuiltinShadowMode::Module);
 154         match module_res.take_types()? {
 155             ModuleDefId::TraitId(it) => Some(it),
 156             _ => None,
 157         }
 158     }
 159
 160     pub fn resolve_path_in_type_ns(
 161         &self,
 162         db: &dyn DefDatabase,
 163         path: &ModPath,
 164     ) -> Option<(TypeNs, Option<usize>)> {
 165         let first_name = path.segments().first()?;
 166         let skip_to_mod = path.kind != PathKind::Plain;
 167         for scope in self.scopes.iter().rev() {
 168             match scope {
 169                 Scope::ExprScope(_) => continue,
 170                 Scope::GenericParams { .. } | Scope::ImplDefScope(_) if skip_to_mod => continue,
 171
 172                 Scope::GenericParams { params, def } => {
 173                     if let Some(local_id) = params.find_type_by_name(first_name) {
 174                         let idx = if path.segments().len() == 1 { None } else { Some(1) };
 175                         return Some((
 176                             TypeNs::GenericParam(TypeParamId { local_id, parent: *def }),
 177                             idx,
 178                         ));
 179                     }
 180                 }
 181                 Scope::ImplDefScope(impl_) => {
 182                     if first_name == &name![Self] {
 183                         let idx = if path.segments().len() == 1 { None } else { Some(1) };
 184                         return Some((TypeNs::SelfType(*impl_), idx));
 185                     }
 186                 }
 187                 Scope::AdtScope(adt) => {
 188                     if first_name == &name![Self] {
 189                         let idx = if path.segments().len() == 1 { None } else { Some(1) };
 190                         return Some((TypeNs::AdtSelfType(*adt), idx));
 191                     }
 192                 }
 193                 Scope::ModuleScope(m) => {
 194                     if let Some(res) = m.resolve_path_in_type_ns(db, path) {
 195                         return Some(res);
 196                     }
 197                 }
 198             }
 199         }
 200         None
 201     }
 202
 203     pub fn resolve_path_in_type_ns_fully(
 204         &self,
 205         db: &dyn DefDatabase,
 206         path: &ModPath,
 207     ) -> Option<TypeNs> {
 208         let (res, unresolved) = self.resolve_path_in_type_ns(db, path)?;
 209         if unresolved.is_some() {
 210             return None;
 211         }
 212         Some(res)
 213     }
 214
 215     pub fn resolve_visibility(
 216         &self,
 217         db: &dyn DefDatabase,
 218         visibility: &RawVisibility,
 219     ) -> Option<Visibility> {
 220         match visibility {
 221             RawVisibility::Module(_) => {
 222                 let (item_map, module) = match self.module_scope() {
 223                     Some(it) => it,
 224                     None => return None,
 225                 };
 226                 item_map.resolve_visibility(db, module, visibility)
 227             }
 228             RawVisibility::Public => Some(Visibility::Public),
 229         }
 230     }
 231
 232     pub fn resolve_path_in_value_ns(
 233         &self,
 234         db: &dyn DefDatabase,
 235         path: &ModPath,
 236     ) -> Option<ResolveValueResult> {
 237         let n_segments = path.segments().len();
 238         let tmp = name![self];
 239         let first_name = if path.is_self() { &tmp } else { path.segments().first()? };
 240         let skip_to_mod = path.kind != PathKind::Plain && !path.is_self();
 241         for scope in self.scopes.iter().rev() {
 242             match scope {
 243                 Scope::AdtScope(_)
 244                 | Scope::ExprScope(_)
 245                 | Scope::GenericParams { .. }
 246                 | Scope::ImplDefScope(_)
 247                     if skip_to_mod =>
 248                 {
 249                     continue
 250                 }
 251
 252                 Scope::ExprScope(scope) if n_segments <= 1 => {
 253                     let entry = scope
 254                         .expr_scopes
 255                         .entries(scope.scope_id)
 256                         .iter()
 257                         .find(|entry| entry.name() == first_name);
 258
 259                     if let Some(e) = entry {
 260                         return Some(ResolveValueResult::ValueNs(ValueNs::LocalBinding(e.pat())));
 261                     }
 262                 }
 263                 Scope::ExprScope(_) => continue,
 264
 265                 Scope::GenericParams { params, def } if n_segments > 1 => {
 266                     if let Some(local_id) = params.find_type_by_name(first_name) {
 267                         let ty = TypeNs::GenericParam(TypeParamId { local_id, parent: *def });
 268                         return Some(ResolveValueResult::Partial(ty, 1));
 269                     }
 270                 }
 271                 Scope::GenericParams { params, def } if n_segments == 1 => {
 272                     if let Some(local_id) = params.find_const_by_name(first_name) {
 273                         let val = ValueNs::GenericParam(ConstParamId { local_id, parent: *def });
 274                         return Some(ResolveValueResult::ValueNs(val));
 275                     }
 276                 }
 277                 Scope::GenericParams { .. } => continue,
 278
 279                 Scope::ImplDefScope(impl_) => {
 280                     if first_name == &name![Self] {
 281                         if n_segments > 1 {
 282                             let ty = TypeNs::SelfType(*impl_);
 283                             return Some(ResolveValueResult::Partial(ty, 1));
 284                         } else {
 285                             return Some(ResolveValueResult::ValueNs(ValueNs::ImplSelf(*impl_)));
 286                         }
 287                     }
 288                 }
 289                 Scope::AdtScope(adt) => {
 290                     if n_segments == 1 {
 291                         // bare `Self` doesn't work in the value namespace in a struct/enum definition
 292                         continue;
 293                     }
 294                     if first_name == &name![Self] {
 295                         let ty = TypeNs::AdtSelfType(*adt);
 296                         return Some(ResolveValueResult::Partial(ty, 1));
 297                     }
 298                 }
 299
 300                 Scope::ModuleScope(m) => {
 301                     if let Some(def) = m.resolve_path_in_value_ns(db, path) {
 302                         return Some(def);
 303                     }
 304                 }
 305             }
 306         }
 307
 308         None
 309     }
 310
 311     pub fn resolve_path_in_value_ns_fully(
 312         &self,
 313         db: &dyn DefDatabase,
 314         path: &ModPath,
 315     ) -> Option<ValueNs> {
 316         match self.resolve_path_in_value_ns(db, path)? {
 317             ResolveValueResult::ValueNs(it) => Some(it),
 318             ResolveValueResult::Partial(..) => None,
 319         }
 320     }
 321
 322     pub fn resolve_path_as_macro(
 323         &self,
 324         db: &dyn DefDatabase,
 325         path: &ModPath,
 326     ) -> Option<MacroDefId> {
 327         let (item_map, module) = self.module_scope()?;
 328         item_map.resolve_path(db, module, &path, BuiltinShadowMode::Other).0.take_macros()
 329     }
 330
 331     pub fn process_all_names(&self, db: &dyn DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
 332         for scope in self.scopes.iter().rev() {
 333             scope.process_names(db, f);
 334         }
 335     }
 336
 337     pub fn traits_in_scope(&self, db: &dyn DefDatabase) -> FxHashSet<TraitId> {
 338         let mut traits = FxHashSet::default();
 339         for scope in &self.scopes {
 340             match scope {
 341                 Scope::ModuleScope(m) => {
 342                     if let Some(prelude) = m.def_map.prelude() {
 343                         let prelude_def_map = prelude.def_map(db);
 344                         traits.extend(prelude_def_map[prelude.local_id].scope.traits());
 345                     }
 346                     traits.extend(m.def_map[m.module_id].scope.traits());
 347
 348                     // Add all traits that are in scope because of the containing DefMaps
 349                     m.def_map.with_ancestor_maps(db, m.module_id, &mut |def_map, module| {
 350                         if let Some(prelude) = def_map.prelude() {
 351                             let prelude_def_map = prelude.def_map(db);
 352                             traits.extend(prelude_def_map[prelude.local_id].scope.traits());
 353                         }
 354                         traits.extend(def_map[module].scope.traits());
 355                         None::<()>
 356                     });
 357                 }
 358                 &Scope::ImplDefScope(impl_) => {
 359                     if let Some(target_trait) = &db.impl_data(impl_).target_trait {
 360                         if let Some(TypeNs::TraitId(trait_)) =
 361                             self.resolve_path_in_type_ns_fully(db, target_trait.path.mod_path())
 362                         {
 363                             traits.insert(trait_);
 364                         }
 365                     }
 366                 }
 367                 _ => (),
 368             }
 369         }
 370         traits
 371     }
 372
 373     fn module_scope(&self) -> Option<(&DefMap, LocalModuleId)> {
 374         self.scopes.iter().rev().find_map(|scope| match scope {
 375             Scope::ModuleScope(m) => Some((&*m.def_map, m.module_id)),
 376
 377             _ => None,
 378         })
 379     }
 380
 381     pub fn module(&self) -> Option<ModuleId> {
 382         let (def_map, local_id) = self.module_scope()?;
 383         Some(def_map.module_id(local_id))
 384     }
 385
 386     pub fn krate(&self) -> Option<CrateId> {
 387         // FIXME: can this ever be `None`?
 388         self.module_scope().map(|t| t.0.krate())
 389     }
 390
 391     pub fn where_predicates_in_scope<'a>(
 392         &'a self,
 393     ) -> impl Iterator<Item = &'a crate::generics::WherePredicate> + 'a {
 394         self.scopes
 395             .iter()
 396             .rev()
 397             .filter_map(|scope| match scope {
 398                 Scope::GenericParams { params, .. } => Some(params),
 399                 _ => None,
 400             })
 401             .flat_map(|params| params.where_predicates.iter())
 402     }
 403
 404     pub fn generic_def(&self) -> Option<GenericDefId> {
 405         self.scopes.iter().rev().find_map(|scope| match scope {
 406             Scope::GenericParams { def, .. } => Some(*def),
 407             _ => None,
 408         })
 409     }
 410
 411     pub fn body_owner(&self) -> Option<DefWithBodyId> {
 412         self.scopes.iter().rev().find_map(|scope| match scope {
 413             Scope::ExprScope(it) => Some(it.owner),
 414             _ => None,
 415         })
 416     }
 417 }
 418
 419 pub enum ScopeDef {
 420     PerNs(PerNs),
 421     ImplSelfType(ImplId),
 422     AdtSelfType(AdtId),
 423     GenericParam(GenericParamId),
 424     Local(PatId),
 425     Label(LabelId),
 426 }
 427
 428 impl Scope {
 429     fn process_names(&self, db: &dyn DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
 430         let mut seen = FxHashSet::default();
 431         match self {
 432             Scope::ModuleScope(m) => {
 433                 // FIXME: should we provide `self` here?
 434                 // f(
 435                 //     Name::self_param(),
 436                 //     PerNs::types(Resolution::Def {
 437                 //         def: m.module.into(),
 438                 //     }),
 439                 // );
 440                 m.def_map[m.module_id].scope.entries().for_each(|(name, def)| {
 441                     f(name.clone(), ScopeDef::PerNs(def));
 442                 });
 443                 m.def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
 444                     let scope = PerNs::macros(macro_, Visibility::Public);
 445                     seen.insert((name.clone(), scope));
 446                     f(name.clone(), ScopeDef::PerNs(scope));
 447                 });
 448                 m.def_map.extern_prelude().for_each(|(name, &def)| {
 449                     f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public)));
 450                 });
 451                 BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
 452                     f(name.clone(), ScopeDef::PerNs(def));
 453                 });
 454                 if let Some(prelude) = m.def_map.prelude() {
 455                     let prelude_def_map = prelude.def_map(db);
 456                     prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| {
 457                         let seen_tuple = (name.clone(), def);
 458                         if !seen.contains(&seen_tuple) {
 459                             f(seen_tuple.0, ScopeDef::PerNs(def));
 460                         }
 461                     });
 462                 }
 463             }
 464             &Scope::GenericParams { ref params, def: parent } => {
 465                 for (local_id, param) in params.types.iter() {
 466                     if let Some(ref name) = param.name {
 467                         let id = TypeParamId { local_id, parent };
 468                         f(name.clone(), ScopeDef::GenericParam(id.into()))
 469                     }
 470                 }
 471                 for (local_id, param) in params.consts.iter() {
 472                     let id = ConstParamId { local_id, parent };
 473                     f(param.name.clone(), ScopeDef::GenericParam(id.into()))
 474                 }
 475                 for (local_id, param) in params.lifetimes.iter() {
 476                     let id = LifetimeParamId { local_id, parent };
 477                     f(param.name.clone(), ScopeDef::GenericParam(id.into()))
 478                 }
 479             }
 480             Scope::ImplDefScope(i) => {
 481                 f(name![Self], ScopeDef::ImplSelfType(*i));
 482             }
 483             Scope::AdtScope(i) => {
 484                 f(name![Self], ScopeDef::AdtSelfType(*i));
 485             }
 486             Scope::ExprScope(scope) => {
 487                 if let Some((label, name)) = scope.expr_scopes.label(scope.scope_id) {
 488                     f(name, ScopeDef::Label(label))
 489                 }
 490                 scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
 491                     f(e.name().clone(), ScopeDef::Local(e.pat()));
 492                 });
 493             }
 494         }
 495     }
 496 }
 497
 498 // needs arbitrary_self_types to be a method... or maybe move to the def?
 499 pub fn resolver_for_expr(db: &dyn DefDatabase, owner: DefWithBodyId, expr_id: ExprId) -> Resolver {
 500     let scopes = db.expr_scopes(owner);
 501     resolver_for_scope(db, owner, scopes.scope_for(expr_id))
 502 }
 503
 504 pub fn resolver_for_scope(
 505     db: &dyn DefDatabase,
 506     owner: DefWithBodyId,
 507     scope_id: Option<ScopeId>,
 508 ) -> Resolver {
 509     let mut r = owner.resolver(db);
 510     let scopes = db.expr_scopes(owner);
 511     let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
 512     for scope in scope_chain.into_iter().rev() {
 513         if let Some(block) = scopes.block(scope) {
 514             if let Some(def_map) = db.block_def_map(block) {
 515                 let root = def_map.root();
 516                 r = r.push_module_scope(def_map, root);
 517                 // FIXME: This adds as many module scopes as there are blocks, but resolving in each
 518                 // already traverses all parents, so this is O(n²). I think we could only store the
 519                 // innermost module scope instead?
 520             }
 521         }
 522
 523         r = r.push_expr_scope(owner, Arc::clone(&scopes), scope);
 524     }
 525     r
 526 }
 527
 528 impl Resolver {
 529     fn push_scope(mut self, scope: Scope) -> Resolver {
 530         self.scopes.push(scope);
 531         self
 532     }
 533
 534     fn push_generic_params_scope(self, db: &dyn DefDatabase, def: GenericDefId) -> Resolver {
 535         let params = db.generic_params(def);
 536         self.push_scope(Scope::GenericParams { def, params })
 537     }
 538
 539     fn push_impl_def_scope(self, impl_def: ImplId) -> Resolver {
 540         self.push_scope(Scope::ImplDefScope(impl_def))
 541     }
 542
 543     fn push_module_scope(self, def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver {
 544         self.push_scope(Scope::ModuleScope(ModuleItemMap { def_map, module_id }))
 545     }
 546
 547     fn push_expr_scope(
 548         self,
 549         owner: DefWithBodyId,
 550         expr_scopes: Arc<ExprScopes>,
 551         scope_id: ScopeId,
 552     ) -> Resolver {
 553         self.push_scope(Scope::ExprScope(ExprScope { owner, expr_scopes, scope_id }))
 554     }
 555 }
 556
 557 impl ModuleItemMap {
 558     fn resolve_path_in_value_ns(
 559         &self,
 560         db: &dyn DefDatabase,
 561         path: &ModPath,
 562     ) -> Option<ResolveValueResult> {
 563         let (module_def, idx) =
 564             self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
 565         match idx {
 566             None => {
 567                 let value = to_value_ns(module_def)?;
 568                 Some(ResolveValueResult::ValueNs(value))
 569             }
 570             Some(idx) => {
 571                 let ty = match module_def.take_types()? {
 572                     ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
 573                     ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
 574                     ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
 575                     ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 576
 577                     ModuleDefId::ModuleId(_)
 578                     | ModuleDefId::FunctionId(_)
 579                     | ModuleDefId::EnumVariantId(_)
 580                     | ModuleDefId::ConstId(_)
 581                     | ModuleDefId::StaticId(_) => return None,
 582                 };
 583                 Some(ResolveValueResult::Partial(ty, idx))
 584             }
 585         }
 586     }
 587
 588     fn resolve_path_in_type_ns(
 589         &self,
 590         db: &dyn DefDatabase,
 591         path: &ModPath,
 592     ) -> Option<(TypeNs, Option<usize>)> {
 593         let (module_def, idx) =
 594             self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
 595         let res = to_type_ns(module_def)?;
 596         Some((res, idx))
 597     }
 598 }
 599
 600 fn to_value_ns(per_ns: PerNs) -> Option<ValueNs> {
 601     let res = match per_ns.take_values()? {
 602         ModuleDefId::FunctionId(it) => ValueNs::FunctionId(it),
 603         ModuleDefId::AdtId(AdtId::StructId(it)) => ValueNs::StructId(it),
 604         ModuleDefId::EnumVariantId(it) => ValueNs::EnumVariantId(it),
 605         ModuleDefId::ConstId(it) => ValueNs::ConstId(it),
 606         ModuleDefId::StaticId(it) => ValueNs::StaticId(it),
 607
 608         ModuleDefId::AdtId(AdtId::EnumId(_))
 609         | ModuleDefId::AdtId(AdtId::UnionId(_))
 610         | ModuleDefId::TraitId(_)
 611         | ModuleDefId::TypeAliasId(_)
 612         | ModuleDefId::BuiltinType(_)
 613         | ModuleDefId::ModuleId(_) => return None,
 614     };
 615     Some(res)
 616 }
 617
 618 fn to_type_ns(per_ns: PerNs) -> Option<TypeNs> {
 619     let res = match per_ns.take_types()? {
 620         ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
 621         ModuleDefId::EnumVariantId(it) => TypeNs::EnumVariantId(it),
 622
 623         ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
 624         ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 625
 626         ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
 627
 628         ModuleDefId::FunctionId(_)
 629         | ModuleDefId::ConstId(_)
 630         | ModuleDefId::StaticId(_)
 631         | ModuleDefId::ModuleId(_) => return None,
 632     };
 633     Some(res)
 634 }
 635
 636 pub trait HasResolver: Copy {
 637     /// Builds a resolver for type references inside this def.
 638     fn resolver(self, db: &dyn DefDatabase) -> Resolver;
 639 }
 640
 641 impl HasResolver for ModuleId {
 642     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 643         let mut def_map = self.def_map(db);
 644         let mut modules = Vec::new();
 645         modules.push((def_map.clone(), self.local_id));
 646         while let Some(parent) = def_map.parent() {
 647             def_map = parent.def_map(db);
 648             modules.push((def_map.clone(), parent.local_id));
 649         }
 650         let mut resolver = Resolver::default();
 651         for (def_map, module) in modules.into_iter().rev() {
 652             resolver = resolver.push_module_scope(def_map, module);
 653         }
 654         resolver
 655     }
 656 }
 657
 658 impl HasResolver for TraitId {
 659     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 660         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 661     }
 662 }
 663
 664 impl<T: Into<AdtId> + Copy> HasResolver for T {
 665     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 666         let def = self.into();
 667         def.module(db)
 668             .resolver(db)
 669             .push_generic_params_scope(db, def.into())
 670             .push_scope(Scope::AdtScope(def))
 671     }
 672 }
 673
 674 impl HasResolver for FunctionId {
 675     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 676         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 677     }
 678 }
 679
 680 impl HasResolver for ConstId {
 681     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 682         self.lookup(db).container.resolver(db)
 683     }
 684 }
 685
 686 impl HasResolver for StaticId {
 687     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 688         self.lookup(db).container.resolver(db)
 689     }
 690 }
 691
 692 impl HasResolver for TypeAliasId {
 693     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 694         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 695     }
 696 }
 697
 698 impl HasResolver for ImplId {
 699     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 700         self.lookup(db)
 701             .container
 702             .resolver(db)
 703             .push_generic_params_scope(db, self.into())
 704             .push_impl_def_scope(self)
 705     }
 706 }
 707
 708 impl HasResolver for DefWithBodyId {
 709     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 710         match self {
 711             DefWithBodyId::ConstId(c) => c.resolver(db),
 712             DefWithBodyId::FunctionId(f) => f.resolver(db),
 713             DefWithBodyId::StaticId(s) => s.resolver(db),
 714         }
 715     }
 716 }
 717
 718 impl HasResolver for AssocContainerId {
 719     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 720         match self {
 721             AssocContainerId::ModuleId(it) => it.resolver(db),
 722             AssocContainerId::TraitId(it) => it.resolver(db),
 723             AssocContainerId::ImplId(it) => it.resolver(db),
 724         }
 725     }
 726 }
 727
 728 impl HasResolver for GenericDefId {
 729     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 730         match self {
 731             GenericDefId::FunctionId(inner) => inner.resolver(db),
 732             GenericDefId::AdtId(adt) => adt.resolver(db),
 733             GenericDefId::TraitId(inner) => inner.resolver(db),
 734             GenericDefId::TypeAliasId(inner) => inner.resolver(db),
 735             GenericDefId::ImplId(inner) => inner.resolver(db),
 736             GenericDefId::EnumVariantId(inner) => inner.parent.resolver(db),
 737             GenericDefId::ConstId(inner) => inner.resolver(db),
 738         }
 739     }
 740 }
 741
 742 impl HasResolver for VariantId {
 743     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 744         match self {
 745             VariantId::EnumVariantId(it) => it.parent.resolver(db),
 746             VariantId::StructId(it) => it.resolver(db),
 747             VariantId::UnionId(it) => it.resolver(db),
 748         }
 749     }
 750 }