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