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             if let Scope::ModuleScope(m) = scope {
 341                 if let Some(prelude) = m.def_map.prelude() {
 342                     let prelude_def_map = prelude.def_map(db);
 343                     traits.extend(prelude_def_map[prelude.local_id].scope.traits());
 344                 }
 345                 traits.extend(m.def_map[m.module_id].scope.traits());
 346
 347                 // Add all traits that are in scope because of the containing DefMaps
 348                 m.def_map.with_ancestor_maps(db, m.module_id, &mut |def_map, module| {
 349                     if let Some(prelude) = def_map.prelude() {
 350                         let prelude_def_map = prelude.def_map(db);
 351                         traits.extend(prelude_def_map[prelude.local_id].scope.traits());
 352                     }
 353                     traits.extend(def_map[module].scope.traits());
 354                     None::<()>
 355                 });
 356             }
 357         }
 358         traits
 359     }
 360
 361     fn module_scope(&self) -> Option<(&DefMap, LocalModuleId)> {
 362         self.scopes.iter().rev().find_map(|scope| match scope {
 363             Scope::ModuleScope(m) => Some((&*m.def_map, m.module_id)),
 364
 365             _ => None,
 366         })
 367     }
 368
 369     pub fn module(&self) -> Option<ModuleId> {
 370         let (def_map, local_id) = self.module_scope()?;
 371         Some(def_map.module_id(local_id))
 372     }
 373
 374     pub fn krate(&self) -> Option<CrateId> {
 375         // FIXME: can this ever be `None`?
 376         self.module_scope().map(|t| t.0.krate())
 377     }
 378
 379     pub fn where_predicates_in_scope<'a>(
 380         &'a self,
 381     ) -> impl Iterator<Item = &'a crate::generics::WherePredicate> + 'a {
 382         self.scopes
 383             .iter()
 384             .rev()
 385             .filter_map(|scope| match scope {
 386                 Scope::GenericParams { params, .. } => Some(params),
 387                 _ => None,
 388             })
 389             .flat_map(|params| params.where_predicates.iter())
 390     }
 391
 392     pub fn generic_def(&self) -> Option<GenericDefId> {
 393         self.scopes.iter().rev().find_map(|scope| match scope {
 394             Scope::GenericParams { def, .. } => Some(*def),
 395             _ => None,
 396         })
 397     }
 398
 399     pub fn body_owner(&self) -> Option<DefWithBodyId> {
 400         self.scopes.iter().rev().find_map(|scope| match scope {
 401             Scope::ExprScope(it) => Some(it.owner),
 402             _ => None,
 403         })
 404     }
 405 }
 406
 407 pub enum ScopeDef {
 408     PerNs(PerNs),
 409     ImplSelfType(ImplId),
 410     AdtSelfType(AdtId),
 411     GenericParam(GenericParamId),
 412     Local(PatId),
 413     Label(LabelId),
 414 }
 415
 416 impl Scope {
 417     fn process_names(&self, db: &dyn DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
 418         let mut seen = FxHashSet::default();
 419         match self {
 420             Scope::ModuleScope(m) => {
 421                 // FIXME: should we provide `self` here?
 422                 // f(
 423                 //     Name::self_param(),
 424                 //     PerNs::types(Resolution::Def {
 425                 //         def: m.module.into(),
 426                 //     }),
 427                 // );
 428                 m.def_map[m.module_id].scope.entries().for_each(|(name, def)| {
 429                     f(name.clone(), ScopeDef::PerNs(def));
 430                 });
 431                 m.def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
 432                     let scope = PerNs::macros(macro_, Visibility::Public);
 433                     seen.insert((name.clone(), scope));
 434                     f(name.clone(), ScopeDef::PerNs(scope));
 435                 });
 436                 m.def_map.extern_prelude().for_each(|(name, &def)| {
 437                     f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public)));
 438                 });
 439                 BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
 440                     f(name.clone(), ScopeDef::PerNs(def));
 441                 });
 442                 if let Some(prelude) = m.def_map.prelude() {
 443                     let prelude_def_map = prelude.def_map(db);
 444                     prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| {
 445                         let seen_tuple = (name.clone(), def);
 446                         if !seen.contains(&seen_tuple) {
 447                             f(seen_tuple.0, ScopeDef::PerNs(def));
 448                         }
 449                     });
 450                 }
 451             }
 452             &Scope::GenericParams { ref params, def: parent } => {
 453                 for (local_id, param) in params.types.iter() {
 454                     if let Some(ref name) = param.name {
 455                         let id = TypeParamId { local_id, parent };
 456                         f(name.clone(), ScopeDef::GenericParam(id.into()))
 457                     }
 458                 }
 459                 for (local_id, param) in params.consts.iter() {
 460                     let id = ConstParamId { local_id, parent };
 461                     f(param.name.clone(), ScopeDef::GenericParam(id.into()))
 462                 }
 463                 for (local_id, param) in params.lifetimes.iter() {
 464                     let id = LifetimeParamId { local_id, parent };
 465                     f(param.name.clone(), ScopeDef::GenericParam(id.into()))
 466                 }
 467             }
 468             Scope::ImplDefScope(i) => {
 469                 f(name![Self], ScopeDef::ImplSelfType(*i));
 470             }
 471             Scope::AdtScope(i) => {
 472                 f(name![Self], ScopeDef::AdtSelfType(*i));
 473             }
 474             Scope::ExprScope(scope) => {
 475                 if let Some((label, name)) = scope.expr_scopes.label(scope.scope_id) {
 476                     f(name, ScopeDef::Label(label))
 477                 }
 478                 scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
 479                     f(e.name().clone(), ScopeDef::Local(e.pat()));
 480                 });
 481             }
 482         }
 483     }
 484 }
 485
 486 // needs arbitrary_self_types to be a method... or maybe move to the def?
 487 pub fn resolver_for_expr(db: &dyn DefDatabase, owner: DefWithBodyId, expr_id: ExprId) -> Resolver {
 488     let scopes = db.expr_scopes(owner);
 489     resolver_for_scope(db, owner, scopes.scope_for(expr_id))
 490 }
 491
 492 pub fn resolver_for_scope(
 493     db: &dyn DefDatabase,
 494     owner: DefWithBodyId,
 495     scope_id: Option<ScopeId>,
 496 ) -> Resolver {
 497     let mut r = owner.resolver(db);
 498     let scopes = db.expr_scopes(owner);
 499     let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
 500     for scope in scope_chain.into_iter().rev() {
 501         if let Some(block) = scopes.block(scope) {
 502             if let Some(def_map) = db.block_def_map(block) {
 503                 let root = def_map.root();
 504                 r = r.push_module_scope(def_map, root);
 505                 // FIXME: This adds as many module scopes as there are blocks, but resolving in each
 506                 // already traverses all parents, so this is O(n²). I think we could only store the
 507                 // innermost module scope instead?
 508             }
 509         }
 510
 511         r = r.push_expr_scope(owner, Arc::clone(&scopes), scope);
 512     }
 513     r
 514 }
 515
 516 impl Resolver {
 517     fn push_scope(mut self, scope: Scope) -> Resolver {
 518         self.scopes.push(scope);
 519         self
 520     }
 521
 522     fn push_generic_params_scope(self, db: &dyn DefDatabase, def: GenericDefId) -> Resolver {
 523         let params = db.generic_params(def);
 524         self.push_scope(Scope::GenericParams { def, params })
 525     }
 526
 527     fn push_impl_def_scope(self, impl_def: ImplId) -> Resolver {
 528         self.push_scope(Scope::ImplDefScope(impl_def))
 529     }
 530
 531     fn push_module_scope(self, def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver {
 532         self.push_scope(Scope::ModuleScope(ModuleItemMap { def_map, module_id }))
 533     }
 534
 535     fn push_expr_scope(
 536         self,
 537         owner: DefWithBodyId,
 538         expr_scopes: Arc<ExprScopes>,
 539         scope_id: ScopeId,
 540     ) -> Resolver {
 541         self.push_scope(Scope::ExprScope(ExprScope { owner, expr_scopes, scope_id }))
 542     }
 543 }
 544
 545 impl ModuleItemMap {
 546     fn resolve_path_in_value_ns(
 547         &self,
 548         db: &dyn DefDatabase,
 549         path: &ModPath,
 550     ) -> Option<ResolveValueResult> {
 551         let (module_def, idx) =
 552             self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
 553         match idx {
 554             None => {
 555                 let value = to_value_ns(module_def)?;
 556                 Some(ResolveValueResult::ValueNs(value))
 557             }
 558             Some(idx) => {
 559                 let ty = match module_def.take_types()? {
 560                     ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
 561                     ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
 562                     ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
 563                     ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 564
 565                     ModuleDefId::ModuleId(_)
 566                     | ModuleDefId::FunctionId(_)
 567                     | ModuleDefId::EnumVariantId(_)
 568                     | ModuleDefId::ConstId(_)
 569                     | ModuleDefId::StaticId(_) => return None,
 570                 };
 571                 Some(ResolveValueResult::Partial(ty, idx))
 572             }
 573         }
 574     }
 575
 576     fn resolve_path_in_type_ns(
 577         &self,
 578         db: &dyn DefDatabase,
 579         path: &ModPath,
 580     ) -> Option<(TypeNs, Option<usize>)> {
 581         let (module_def, idx) =
 582             self.def_map.resolve_path_locally(db, self.module_id, &path, BuiltinShadowMode::Other);
 583         let res = to_type_ns(module_def)?;
 584         Some((res, idx))
 585     }
 586 }
 587
 588 fn to_value_ns(per_ns: PerNs) -> Option<ValueNs> {
 589     let res = match per_ns.take_values()? {
 590         ModuleDefId::FunctionId(it) => ValueNs::FunctionId(it),
 591         ModuleDefId::AdtId(AdtId::StructId(it)) => ValueNs::StructId(it),
 592         ModuleDefId::EnumVariantId(it) => ValueNs::EnumVariantId(it),
 593         ModuleDefId::ConstId(it) => ValueNs::ConstId(it),
 594         ModuleDefId::StaticId(it) => ValueNs::StaticId(it),
 595
 596         ModuleDefId::AdtId(AdtId::EnumId(_))
 597         | ModuleDefId::AdtId(AdtId::UnionId(_))
 598         | ModuleDefId::TraitId(_)
 599         | ModuleDefId::TypeAliasId(_)
 600         | ModuleDefId::BuiltinType(_)
 601         | ModuleDefId::ModuleId(_) => return None,
 602     };
 603     Some(res)
 604 }
 605
 606 fn to_type_ns(per_ns: PerNs) -> Option<TypeNs> {
 607     let res = match per_ns.take_types()? {
 608         ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
 609         ModuleDefId::EnumVariantId(it) => TypeNs::EnumVariantId(it),
 610
 611         ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
 612         ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 613
 614         ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
 615
 616         ModuleDefId::FunctionId(_)
 617         | ModuleDefId::ConstId(_)
 618         | ModuleDefId::StaticId(_)
 619         | ModuleDefId::ModuleId(_) => return None,
 620     };
 621     Some(res)
 622 }
 623
 624 pub trait HasResolver: Copy {
 625     /// Builds a resolver for type references inside this def.
 626     fn resolver(self, db: &dyn DefDatabase) -> Resolver;
 627 }
 628
 629 impl HasResolver for ModuleId {
 630     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 631         let mut def_map = self.def_map(db);
 632         let mut modules = Vec::new();
 633         modules.push((def_map.clone(), self.local_id));
 634         while let Some(parent) = def_map.parent() {
 635             def_map = parent.def_map(db);
 636             modules.push((def_map.clone(), parent.local_id));
 637         }
 638         let mut resolver = Resolver::default();
 639         for (def_map, module) in modules.into_iter().rev() {
 640             resolver = resolver.push_module_scope(def_map, module);
 641         }
 642         resolver
 643     }
 644 }
 645
 646 impl HasResolver for TraitId {
 647     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 648         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 649     }
 650 }
 651
 652 impl<T: Into<AdtId> + Copy> HasResolver for T {
 653     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 654         let def = self.into();
 655         def.module(db)
 656             .resolver(db)
 657             .push_generic_params_scope(db, def.into())
 658             .push_scope(Scope::AdtScope(def))
 659     }
 660 }
 661
 662 impl HasResolver for FunctionId {
 663     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 664         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 665     }
 666 }
 667
 668 impl HasResolver for ConstId {
 669     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 670         self.lookup(db).container.resolver(db)
 671     }
 672 }
 673
 674 impl HasResolver for StaticId {
 675     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 676         self.lookup(db).container.resolver(db)
 677     }
 678 }
 679
 680 impl HasResolver for TypeAliasId {
 681     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 682         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 683     }
 684 }
 685
 686 impl HasResolver for ImplId {
 687     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 688         self.lookup(db)
 689             .container
 690             .resolver(db)
 691             .push_generic_params_scope(db, self.into())
 692             .push_impl_def_scope(self)
 693     }
 694 }
 695
 696 impl HasResolver for DefWithBodyId {
 697     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 698         match self {
 699             DefWithBodyId::ConstId(c) => c.resolver(db),
 700             DefWithBodyId::FunctionId(f) => f.resolver(db),
 701             DefWithBodyId::StaticId(s) => s.resolver(db),
 702         }
 703     }
 704 }
 705
 706 impl HasResolver for AssocContainerId {
 707     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 708         match self {
 709             AssocContainerId::ModuleId(it) => it.resolver(db),
 710             AssocContainerId::TraitId(it) => it.resolver(db),
 711             AssocContainerId::ImplId(it) => it.resolver(db),
 712         }
 713     }
 714 }
 715
 716 impl HasResolver for GenericDefId {
 717     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 718         match self {
 719             GenericDefId::FunctionId(inner) => inner.resolver(db),
 720             GenericDefId::AdtId(adt) => adt.resolver(db),
 721             GenericDefId::TraitId(inner) => inner.resolver(db),
 722             GenericDefId::TypeAliasId(inner) => inner.resolver(db),
 723             GenericDefId::ImplId(inner) => inner.resolver(db),
 724             GenericDefId::EnumVariantId(inner) => inner.parent.resolver(db),
 725             GenericDefId::ConstId(inner) => inner.resolver(db),
 726         }
 727     }
 728 }
 729
 730 impl HasResolver for VariantId {
 731     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 732         match self {
 733             VariantId::EnumVariantId(it) => it.parent.resolver(db),
 734             VariantId::StructId(it) => it.resolver(db),
 735             VariantId::UnionId(it) => it.resolver(db),
 736         }
 737     }
 738 }