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