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