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