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