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 indexmap::IndexMap;
  10 use rustc_hash::FxHashSet;
  11 use smallvec::{smallvec, SmallVec};
  12
  13 use crate::{
  14     body::scope::{ExprScopes, ScopeId},
  15     builtin_type::BuiltinType,
  16     db::DefDatabase,
  17     expr::{ExprId, LabelId, PatId},
  18     generics::GenericParams,
  19     intern::Interned,
  20     item_scope::{BuiltinShadowMode, BUILTIN_SCOPE},
  21     nameres::DefMap,
  22     path::{ModPath, PathKind},
  23     per_ns::PerNs,
  24     visibility::{RawVisibility, Visibility},
  25     AdtId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId,
  26     FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId,
  27     LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
  28     TypeParamId, VariantId,
  29 };
  30
  31 #[derive(Debug, Clone, Default)]
  32 pub struct Resolver {
  33     /// The stack of scopes, where the inner-most scope is the last item.
  34     ///
  35     /// When using, you generally want to process the scopes in reverse order,
  36     /// there's `scopes` *method* for that.
  37     scopes: Vec<Scope>,
  38 }
  39
  40 // FIXME how to store these best
  41 #[derive(Debug, Clone)]
  42 struct ModuleItemMap {
  43     def_map: Arc<DefMap>,
  44     module_id: LocalModuleId,
  45 }
  46
  47 #[derive(Debug, Clone)]
  48 struct ExprScope {
  49     owner: DefWithBodyId,
  50     expr_scopes: Arc<ExprScopes>,
  51     scope_id: ScopeId,
  52 }
  53
  54 #[derive(Debug, Clone)]
  55 enum Scope {
  56     /// All the items and imported names of a module
  57     ModuleScope(ModuleItemMap),
  58     /// Brings the generic parameters of an item into scope
  59     GenericParams { def: GenericDefId, params: Interned<GenericParams> },
  60     /// Brings `Self` in `impl` block into scope
  61     ImplDefScope(ImplId),
  62     /// Brings `Self` in enum, struct and union definitions into scope
  63     AdtScope(AdtId),
  64     /// Local bindings
  65     ExprScope(ExprScope),
  66 }
  67
  68 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  69 pub enum TypeNs {
  70     SelfType(ImplId),
  71     GenericParam(TypeParamId),
  72     AdtId(AdtId),
  73     AdtSelfType(AdtId),
  74     // Yup, enum variants are added to the types ns, but any usage of variant as
  75     // type is an error.
  76     EnumVariantId(EnumVariantId),
  77     TypeAliasId(TypeAliasId),
  78     BuiltinType(BuiltinType),
  79     TraitId(TraitId),
  80     // Module belong to type ns, but the resolver is used when all module paths
  81     // are fully resolved.
  82     // ModuleId(ModuleId)
  83 }
  84
  85 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  86 pub enum ResolveValueResult {
  87     ValueNs(ValueNs),
  88     Partial(TypeNs, usize),
  89 }
  90
  91 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
  92 pub enum ValueNs {
  93     ImplSelf(ImplId),
  94     LocalBinding(PatId),
  95     FunctionId(FunctionId),
  96     ConstId(ConstId),
  97     StaticId(StaticId),
  98     StructId(StructId),
  99     EnumVariantId(EnumVariantId),
 100     GenericParam(ConstParamId),
 101 }
 102
 103 impl Resolver {
 104     /// Resolve known trait from std, like `std::futures::Future`
 105     pub fn resolve_known_trait(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<TraitId> {
 106         let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
 107         match res {
 108             ModuleDefId::TraitId(it) => Some(it),
 109             _ => None,
 110         }
 111     }
 112
 113     /// Resolve known struct from std, like `std::boxed::Box`
 114     pub fn resolve_known_struct(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<StructId> {
 115         let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
 116         match res {
 117             ModuleDefId::AdtId(AdtId::StructId(it)) => Some(it),
 118             _ => None,
 119         }
 120     }
 121
 122     /// Resolve known enum from std, like `std::result::Result`
 123     pub fn resolve_known_enum(&self, db: &dyn DefDatabase, path: &ModPath) -> Option<EnumId> {
 124         let res = self.resolve_module_path(db, path, BuiltinShadowMode::Other).take_types()?;
 125         match res {
 126             ModuleDefId::AdtId(AdtId::EnumId(it)) => Some(it),
 127             _ => None,
 128         }
 129     }
 130
 131     fn scopes(&self) -> impl Iterator<Item = &Scope> {
 132         self.scopes.iter().rev()
 133     }
 134
 135     fn resolve_module_path(
 136         &self,
 137         db: &dyn DefDatabase,
 138         path: &ModPath,
 139         shadow: BuiltinShadowMode,
 140     ) -> PerNs {
 141         let (item_map, module) = match self.module_scope() {
 142             Some(it) => it,
 143             None => return PerNs::none(),
 144         };
 145         let (module_res, segment_index) = item_map.resolve_path(db, module, path, shadow);
 146         if segment_index.is_some() {
 147             return PerNs::none();
 148         }
 149         module_res
 150     }
 151
 152     pub fn resolve_module_path_in_items(&self, db: &dyn DefDatabase, path: &ModPath) -> PerNs {
 153         self.resolve_module_path(db, path, BuiltinShadowMode::Module)
 154     }
 155
 156     pub fn resolve_module_path_in_trait_assoc_items(
 157         &self,
 158         db: &dyn DefDatabase,
 159         path: &ModPath,
 160     ) -> Option<PerNs> {
 161         let (item_map, module) = self.module_scope()?;
 162         let (module_res, idx) = item_map.resolve_path(db, module, path, BuiltinShadowMode::Module);
 163         match module_res.take_types()? {
 164             ModuleDefId::TraitId(it) => {
 165                 let idx = idx?;
 166                 let unresolved = &path.segments()[idx..];
 167                 let assoc = match unresolved {
 168                     [it] => it,
 169                     _ => return None,
 170                 };
 171                 let &(_, assoc) = db.trait_data(it).items.iter().find(|(n, _)| n == assoc)?;
 172                 Some(match assoc {
 173                     AssocItemId::FunctionId(it) => PerNs::values(it.into(), Visibility::Public),
 174                     AssocItemId::ConstId(it) => PerNs::values(it.into(), Visibility::Public),
 175                     AssocItemId::TypeAliasId(it) => PerNs::types(it.into(), Visibility::Public),
 176                 })
 177             }
 178             _ => None,
 179         }
 180     }
 181
 182     pub fn resolve_path_in_type_ns(
 183         &self,
 184         db: &dyn DefDatabase,
 185         path: &ModPath,
 186     ) -> Option<(TypeNs, Option<usize>)> {
 187         let first_name = path.segments().first()?;
 188         let skip_to_mod = path.kind != PathKind::Plain;
 189         for scope in self.scopes() {
 190             match scope {
 191                 Scope::ExprScope(_) => continue,
 192                 Scope::GenericParams { .. } | Scope::ImplDefScope(_) if skip_to_mod => continue,
 193
 194                 Scope::GenericParams { params, def } => {
 195                     if let Some(local_id) = params.find_type_by_name(first_name) {
 196                         let idx = if path.segments().len() == 1 { None } else { Some(1) };
 197                         return Some((
 198                             TypeNs::GenericParam(TypeParamId { local_id, parent: *def }),
 199                             idx,
 200                         ));
 201                     }
 202                 }
 203                 Scope::ImplDefScope(impl_) => {
 204                     if first_name == &name![Self] {
 205                         let idx = if path.segments().len() == 1 { None } else { Some(1) };
 206                         return Some((TypeNs::SelfType(*impl_), idx));
 207                     }
 208                 }
 209                 Scope::AdtScope(adt) => {
 210                     if first_name == &name![Self] {
 211                         let idx = if path.segments().len() == 1 { None } else { Some(1) };
 212                         return Some((TypeNs::AdtSelfType(*adt), idx));
 213                     }
 214                 }
 215                 Scope::ModuleScope(m) => {
 216                     if let Some(res) = m.resolve_path_in_type_ns(db, path) {
 217                         return Some(res);
 218                     }
 219                 }
 220             }
 221         }
 222         None
 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() {
 264             match scope {
 265                 Scope::AdtScope(_)
 266                 | Scope::ExprScope(_)
 267                 | Scope::GenericParams { .. }
 268                 | Scope::ImplDefScope(_)
 269                     if skip_to_mod =>
 270                 {
 271                     continue
 272                 }
 273
 274                 Scope::ExprScope(scope) if n_segments <= 1 => {
 275                     let entry = scope
 276                         .expr_scopes
 277                         .entries(scope.scope_id)
 278                         .iter()
 279                         .find(|entry| entry.name() == first_name);
 280
 281                     if let Some(e) = entry {
 282                         return Some(ResolveValueResult::ValueNs(ValueNs::LocalBinding(e.pat())));
 283                     }
 284                 }
 285                 Scope::ExprScope(_) => continue,
 286
 287                 Scope::GenericParams { params, def } if n_segments > 1 => {
 288                     if let Some(local_id) = params.find_type_by_name(first_name) {
 289                         let ty = TypeNs::GenericParam(TypeParamId { local_id, parent: *def });
 290                         return Some(ResolveValueResult::Partial(ty, 1));
 291                     }
 292                 }
 293                 Scope::GenericParams { params, def } if n_segments == 1 => {
 294                     if let Some(local_id) = params.find_const_by_name(first_name) {
 295                         let val = ValueNs::GenericParam(ConstParamId { local_id, parent: *def });
 296                         return Some(ResolveValueResult::ValueNs(val));
 297                     }
 298                 }
 299                 Scope::GenericParams { .. } => continue,
 300
 301                 Scope::ImplDefScope(impl_) => {
 302                     if first_name == &name![Self] {
 303                         if n_segments > 1 {
 304                             let ty = TypeNs::SelfType(*impl_);
 305                             return Some(ResolveValueResult::Partial(ty, 1));
 306                         } else {
 307                             return Some(ResolveValueResult::ValueNs(ValueNs::ImplSelf(*impl_)));
 308                         }
 309                     }
 310                 }
 311                 Scope::AdtScope(adt) => {
 312                     if n_segments == 1 {
 313                         // bare `Self` doesn't work in the value namespace in a struct/enum definition
 314                         continue;
 315                     }
 316                     if first_name == &name![Self] {
 317                         let ty = TypeNs::AdtSelfType(*adt);
 318                         return Some(ResolveValueResult::Partial(ty, 1));
 319                     }
 320                 }
 321
 322                 Scope::ModuleScope(m) => {
 323                     if let Some(def) = m.resolve_path_in_value_ns(db, path) {
 324                         return Some(def);
 325                     }
 326                 }
 327             }
 328         }
 329
 330         None
 331     }
 332
 333     pub fn resolve_path_in_value_ns_fully(
 334         &self,
 335         db: &dyn DefDatabase,
 336         path: &ModPath,
 337     ) -> Option<ValueNs> {
 338         match self.resolve_path_in_value_ns(db, path)? {
 339             ResolveValueResult::ValueNs(it) => Some(it),
 340             ResolveValueResult::Partial(..) => None,
 341         }
 342     }
 343
 344     pub fn resolve_path_as_macro(
 345         &self,
 346         db: &dyn DefDatabase,
 347         path: &ModPath,
 348     ) -> Option<MacroDefId> {
 349         let (item_map, module) = self.module_scope()?;
 350         item_map.resolve_path(db, module, path, BuiltinShadowMode::Other).0.take_macros()
 351     }
 352
 353     /// Returns a set of names available in the current scope.
 354     ///
 355     /// Note that this is a somewhat fuzzy concept -- internally, the compiler
 356     /// doesn't necessary follow a strict scoping discipline. Rathe, it just
 357     /// tells for each ident what it resolves to.
 358     ///
 359     /// A good example is something like `str::from_utf8`. From scopes point of
 360     /// view, this code is erroneous -- both `str` module and `str` type occupy
 361     /// the same type namespace.
 362     ///
 363     /// We don't try to model that super-correctly -- this functionality is
 364     /// primarily exposed for completions.
 365     ///
 366     /// Note that in Rust one name can be bound to several items:
 367     ///
 368     /// ```
 369     /// macro_rules! t { () => (()) }
 370     /// type t = t!();
 371     /// const t: t = t!()
 372     /// ```
 373     ///
 374     /// That's why we return a multimap.
 375     ///
 376     /// The shadowing is accounted for: in
 377     ///
 378     /// ```
 379     /// let x = 92;
 380     /// {
 381     ///     let x = 92;
 382     ///     $0
 383     /// }
 384     /// ```
 385     ///
 386     /// there will be only one entry for `x` in the result.
 387     ///
 388     /// The result is ordered *roughly* from the innermost scope to the
 389     /// outermost: when the name is introduced in two namespaces in two scopes,
 390     /// we use the position of the first scope.
 391     pub fn names_in_scope(&self, db: &dyn DefDatabase) -> IndexMap<Name, SmallVec<[ScopeDef; 1]>> {
 392         let mut res = ScopeNames::default();
 393         for scope in self.scopes() {
 394             scope.process_names(db, &mut res);
 395         }
 396         res.map
 397     }
 398
 399     pub fn traits_in_scope(&self, db: &dyn DefDatabase) -> FxHashSet<TraitId> {
 400         let mut traits = FxHashSet::default();
 401         for scope in self.scopes() {
 402             match scope {
 403                 Scope::ModuleScope(m) => {
 404                     if let Some(prelude) = m.def_map.prelude() {
 405                         let prelude_def_map = prelude.def_map(db);
 406                         traits.extend(prelude_def_map[prelude.local_id].scope.traits());
 407                     }
 408                     traits.extend(m.def_map[m.module_id].scope.traits());
 409
 410                     // Add all traits that are in scope because of the containing DefMaps
 411                     m.def_map.with_ancestor_maps(db, m.module_id, &mut |def_map, module| {
 412                         if let Some(prelude) = def_map.prelude() {
 413                             let prelude_def_map = prelude.def_map(db);
 414                             traits.extend(prelude_def_map[prelude.local_id].scope.traits());
 415                         }
 416                         traits.extend(def_map[module].scope.traits());
 417                         None::<()>
 418                     });
 419                 }
 420                 &Scope::ImplDefScope(impl_) => {
 421                     if let Some(target_trait) = &db.impl_data(impl_).target_trait {
 422                         if let Some(TypeNs::TraitId(trait_)) =
 423                             self.resolve_path_in_type_ns_fully(db, target_trait.path.mod_path())
 424                         {
 425                             traits.insert(trait_);
 426                         }
 427                     }
 428                 }
 429                 _ => (),
 430             }
 431         }
 432         traits
 433     }
 434
 435     fn module_scope(&self) -> Option<(&DefMap, LocalModuleId)> {
 436         self.scopes().find_map(|scope| match scope {
 437             Scope::ModuleScope(m) => Some((&*m.def_map, m.module_id)),
 438
 439             _ => None,
 440         })
 441     }
 442
 443     pub fn module(&self) -> Option<ModuleId> {
 444         let (def_map, local_id) = self.module_scope()?;
 445         Some(def_map.module_id(local_id))
 446     }
 447
 448     pub fn krate(&self) -> Option<CrateId> {
 449         // FIXME: can this ever be `None`?
 450         self.module_scope().map(|t| t.0.krate())
 451     }
 452
 453     pub fn where_predicates_in_scope(
 454         &self,
 455     ) -> impl Iterator<Item = &crate::generics::WherePredicate> {
 456         self.scopes()
 457             .filter_map(|scope| match scope {
 458                 Scope::GenericParams { params, .. } => Some(params),
 459                 _ => None,
 460             })
 461             .flat_map(|params| params.where_predicates.iter())
 462     }
 463
 464     pub fn generic_def(&self) -> Option<GenericDefId> {
 465         self.scopes().find_map(|scope| match scope {
 466             Scope::GenericParams { def, .. } => Some(*def),
 467             _ => None,
 468         })
 469     }
 470
 471     pub fn body_owner(&self) -> Option<DefWithBodyId> {
 472         self.scopes().find_map(|scope| match scope {
 473             Scope::ExprScope(it) => Some(it.owner),
 474             _ => None,
 475         })
 476     }
 477 }
 478
 479 #[derive(Debug, PartialEq, Eq)]
 480 pub enum ScopeDef {
 481     ModuleDef(ModuleDefId),
 482     MacroDef(MacroDefId),
 483     Unknown,
 484     ImplSelfType(ImplId),
 485     AdtSelfType(AdtId),
 486     GenericParam(GenericParamId),
 487     Local(PatId),
 488     Label(LabelId),
 489 }
 490
 491 impl Scope {
 492     fn process_names(&self, db: &dyn DefDatabase, acc: &mut ScopeNames) {
 493         match self {
 494             Scope::ModuleScope(m) => {
 495                 // FIXME: should we provide `self` here?
 496                 // f(
 497                 //     Name::self_param(),
 498                 //     PerNs::types(Resolution::Def {
 499                 //         def: m.module.into(),
 500                 //     }),
 501                 // );
 502                 m.def_map[m.module_id].scope.entries().for_each(|(name, def)| {
 503                     acc.add_per_ns(name, def);
 504                 });
 505                 m.def_map[m.module_id].scope.legacy_macros().for_each(|(name, mac)| {
 506                     acc.add(name, ScopeDef::MacroDef(mac));
 507                 });
 508                 m.def_map.extern_prelude().for_each(|(name, &def)| {
 509                     acc.add(name, ScopeDef::ModuleDef(def));
 510                 });
 511                 BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
 512                     acc.add_per_ns(name, def);
 513                 });
 514                 if let Some(prelude) = m.def_map.prelude() {
 515                     let prelude_def_map = prelude.def_map(db);
 516                     for (name, def) in prelude_def_map[prelude.local_id].scope.entries() {
 517                         acc.add_per_ns(name, def)
 518                     }
 519                 }
 520             }
 521             Scope::GenericParams { params, def: parent } => {
 522                 let parent = *parent;
 523                 for (local_id, param) in params.types.iter() {
 524                     if let Some(name) = &param.name {
 525                         let id = TypeParamId { parent, local_id };
 526                         acc.add(name, ScopeDef::GenericParam(id.into()))
 527                     }
 528                 }
 529                 for (local_id, param) in params.consts.iter() {
 530                     let id = ConstParamId { parent, local_id };
 531                     acc.add(&param.name, ScopeDef::GenericParam(id.into()))
 532                 }
 533                 for (local_id, param) in params.lifetimes.iter() {
 534                     let id = LifetimeParamId { parent, local_id };
 535                     acc.add(&param.name, ScopeDef::GenericParam(id.into()))
 536                 }
 537             }
 538             Scope::ImplDefScope(i) => {
 539                 acc.add(&name![Self], ScopeDef::ImplSelfType(*i));
 540             }
 541             Scope::AdtScope(i) => {
 542                 acc.add(&name![Self], ScopeDef::AdtSelfType(*i));
 543             }
 544             Scope::ExprScope(scope) => {
 545                 if let Some((label, name)) = scope.expr_scopes.label(scope.scope_id) {
 546                     acc.add(&name, ScopeDef::Label(label))
 547                 }
 548                 scope.expr_scopes.entries(scope.scope_id).iter().for_each(|e| {
 549                     acc.add_local(e.name(), e.pat());
 550                 });
 551             }
 552         }
 553     }
 554 }
 555
 556 // needs arbitrary_self_types to be a method... or maybe move to the def?
 557 pub fn resolver_for_expr(db: &dyn DefDatabase, owner: DefWithBodyId, expr_id: ExprId) -> Resolver {
 558     let scopes = db.expr_scopes(owner);
 559     resolver_for_scope(db, owner, scopes.scope_for(expr_id))
 560 }
 561
 562 pub fn resolver_for_scope(
 563     db: &dyn DefDatabase,
 564     owner: DefWithBodyId,
 565     scope_id: Option<ScopeId>,
 566 ) -> Resolver {
 567     let mut r = owner.resolver(db);
 568     let scopes = db.expr_scopes(owner);
 569     let scope_chain = scopes.scope_chain(scope_id).collect::<Vec<_>>();
 570     r.scopes.reserve(scope_chain.len());
 571
 572     for scope in scope_chain.into_iter().rev() {
 573         if let Some(block) = scopes.block(scope) {
 574             if let Some(def_map) = db.block_def_map(block) {
 575                 let root = def_map.root();
 576                 r = r.push_module_scope(def_map, root);
 577                 // FIXME: This adds as many module scopes as there are blocks, but resolving in each
 578                 // already traverses all parents, so this is O(n²). I think we could only store the
 579                 // innermost module scope instead?
 580             }
 581         }
 582
 583         r = r.push_expr_scope(owner, Arc::clone(&scopes), scope);
 584     }
 585     r
 586 }
 587
 588 impl Resolver {
 589     fn push_scope(mut self, scope: Scope) -> Resolver {
 590         self.scopes.push(scope);
 591         self
 592     }
 593
 594     fn push_generic_params_scope(self, db: &dyn DefDatabase, def: GenericDefId) -> Resolver {
 595         let params = db.generic_params(def);
 596         self.push_scope(Scope::GenericParams { def, params })
 597     }
 598
 599     fn push_impl_def_scope(self, impl_def: ImplId) -> Resolver {
 600         self.push_scope(Scope::ImplDefScope(impl_def))
 601     }
 602
 603     fn push_module_scope(self, def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver {
 604         self.push_scope(Scope::ModuleScope(ModuleItemMap { def_map, module_id }))
 605     }
 606
 607     fn push_expr_scope(
 608         self,
 609         owner: DefWithBodyId,
 610         expr_scopes: Arc<ExprScopes>,
 611         scope_id: ScopeId,
 612     ) -> Resolver {
 613         self.push_scope(Scope::ExprScope(ExprScope { owner, expr_scopes, scope_id }))
 614     }
 615 }
 616
 617 impl ModuleItemMap {
 618     fn resolve_path_in_value_ns(
 619         &self,
 620         db: &dyn DefDatabase,
 621         path: &ModPath,
 622     ) -> Option<ResolveValueResult> {
 623         let (module_def, idx) =
 624             self.def_map.resolve_path_locally(db, self.module_id, path, BuiltinShadowMode::Other);
 625         match idx {
 626             None => {
 627                 let value = to_value_ns(module_def)?;
 628                 Some(ResolveValueResult::ValueNs(value))
 629             }
 630             Some(idx) => {
 631                 let ty = match module_def.take_types()? {
 632                     ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
 633                     ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
 634                     ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
 635                     ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 636
 637                     ModuleDefId::ModuleId(_)
 638                     | ModuleDefId::FunctionId(_)
 639                     | ModuleDefId::EnumVariantId(_)
 640                     | ModuleDefId::ConstId(_)
 641                     | ModuleDefId::StaticId(_) => return None,
 642                 };
 643                 Some(ResolveValueResult::Partial(ty, idx))
 644             }
 645         }
 646     }
 647
 648     fn resolve_path_in_type_ns(
 649         &self,
 650         db: &dyn DefDatabase,
 651         path: &ModPath,
 652     ) -> Option<(TypeNs, Option<usize>)> {
 653         let (module_def, idx) =
 654             self.def_map.resolve_path_locally(db, self.module_id, path, BuiltinShadowMode::Other);
 655         let res = to_type_ns(module_def)?;
 656         Some((res, idx))
 657     }
 658 }
 659
 660 fn to_value_ns(per_ns: PerNs) -> Option<ValueNs> {
 661     let res = match per_ns.take_values()? {
 662         ModuleDefId::FunctionId(it) => ValueNs::FunctionId(it),
 663         ModuleDefId::AdtId(AdtId::StructId(it)) => ValueNs::StructId(it),
 664         ModuleDefId::EnumVariantId(it) => ValueNs::EnumVariantId(it),
 665         ModuleDefId::ConstId(it) => ValueNs::ConstId(it),
 666         ModuleDefId::StaticId(it) => ValueNs::StaticId(it),
 667
 668         ModuleDefId::AdtId(AdtId::EnumId(_) | AdtId::UnionId(_))
 669         | ModuleDefId::TraitId(_)
 670         | ModuleDefId::TypeAliasId(_)
 671         | ModuleDefId::BuiltinType(_)
 672         | ModuleDefId::ModuleId(_) => return None,
 673     };
 674     Some(res)
 675 }
 676
 677 fn to_type_ns(per_ns: PerNs) -> Option<TypeNs> {
 678     let res = match per_ns.take_types()? {
 679         ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
 680         ModuleDefId::EnumVariantId(it) => TypeNs::EnumVariantId(it),
 681
 682         ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
 683         ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
 684
 685         ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
 686
 687         ModuleDefId::FunctionId(_)
 688         | ModuleDefId::ConstId(_)
 689         | ModuleDefId::StaticId(_)
 690         | ModuleDefId::ModuleId(_) => return None,
 691     };
 692     Some(res)
 693 }
 694
 695 #[derive(Default)]
 696 struct ScopeNames {
 697     map: IndexMap<Name, SmallVec<[ScopeDef; 1]>>,
 698 }
 699
 700 impl ScopeNames {
 701     fn add(&mut self, name: &Name, def: ScopeDef) {
 702         let set = self.map.entry(name.clone()).or_default();
 703         if !set.contains(&def) {
 704             set.push(def)
 705         }
 706     }
 707     fn add_per_ns(&mut self, name: &Name, def: PerNs) {
 708         if let Some(ty) = &def.types {
 709             self.add(name, ScopeDef::ModuleDef(ty.0))
 710         }
 711         if let Some(val) = &def.values {
 712             self.add(name, ScopeDef::ModuleDef(val.0))
 713         }
 714         if let Some(mac) = &def.macros {
 715             self.add(name, ScopeDef::MacroDef(mac.0))
 716         }
 717         if def.is_none() {
 718             self.add(name, ScopeDef::Unknown)
 719         }
 720     }
 721     fn add_local(&mut self, name: &Name, pat: PatId) {
 722         let set = self.map.entry(name.clone()).or_default();
 723         // XXX: hack, account for local (and only local) shadowing.
 724         //
 725         // This should be somewhat more principled and take namespaces into
 726         // accounts, but, alas, scoping rules are a hoax. `str` type and `str`
 727         // module can be both available in the same scope.
 728         if set.iter().any(|it| matches!(it, &ScopeDef::Local(_))) {
 729             cov_mark::hit!(shadowing_shows_single_completion);
 730             return;
 731         }
 732         set.push(ScopeDef::Local(pat))
 733     }
 734 }
 735
 736 pub trait HasResolver: Copy {
 737     /// Builds a resolver for type references inside this def.
 738     fn resolver(self, db: &dyn DefDatabase) -> Resolver;
 739 }
 740
 741 impl HasResolver for ModuleId {
 742     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 743         let mut def_map = self.def_map(db);
 744         let mut modules: SmallVec<[_; 2]> = smallvec![(def_map.clone(), self.local_id)];
 745         while let Some(parent) = def_map.parent() {
 746             def_map = parent.def_map(db);
 747             modules.push((def_map.clone(), parent.local_id));
 748         }
 749         let mut resolver = Resolver::default();
 750         resolver.scopes.reserve(modules.len());
 751         for (def_map, module) in modules.into_iter().rev() {
 752             resolver = resolver.push_module_scope(def_map, module);
 753         }
 754         resolver
 755     }
 756 }
 757
 758 impl HasResolver for TraitId {
 759     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 760         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 761     }
 762 }
 763
 764 impl<T: Into<AdtId> + Copy> HasResolver for T {
 765     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 766         let def = self.into();
 767         def.module(db)
 768             .resolver(db)
 769             .push_generic_params_scope(db, def.into())
 770             .push_scope(Scope::AdtScope(def))
 771     }
 772 }
 773
 774 impl HasResolver for FunctionId {
 775     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 776         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 777     }
 778 }
 779
 780 impl HasResolver for ConstId {
 781     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 782         self.lookup(db).container.resolver(db)
 783     }
 784 }
 785
 786 impl HasResolver for StaticId {
 787     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 788         self.lookup(db).container.resolver(db)
 789     }
 790 }
 791
 792 impl HasResolver for TypeAliasId {
 793     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 794         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
 795     }
 796 }
 797
 798 impl HasResolver for ImplId {
 799     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 800         self.lookup(db)
 801             .container
 802             .resolver(db)
 803             .push_generic_params_scope(db, self.into())
 804             .push_impl_def_scope(self)
 805     }
 806 }
 807
 808 impl HasResolver for ExternBlockId {
 809     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 810         // Same as parent's
 811         self.lookup(db).container.resolver(db)
 812     }
 813 }
 814
 815 impl HasResolver for DefWithBodyId {
 816     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 817         match self {
 818             DefWithBodyId::ConstId(c) => c.resolver(db),
 819             DefWithBodyId::FunctionId(f) => f.resolver(db),
 820             DefWithBodyId::StaticId(s) => s.resolver(db),
 821         }
 822     }
 823 }
 824
 825 impl HasResolver for ItemContainerId {
 826     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 827         match self {
 828             ItemContainerId::ModuleId(it) => it.resolver(db),
 829             ItemContainerId::TraitId(it) => it.resolver(db),
 830             ItemContainerId::ImplId(it) => it.resolver(db),
 831             ItemContainerId::ExternBlockId(it) => it.resolver(db),
 832         }
 833     }
 834 }
 835
 836 impl HasResolver for GenericDefId {
 837     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 838         match self {
 839             GenericDefId::FunctionId(inner) => inner.resolver(db),
 840             GenericDefId::AdtId(adt) => adt.resolver(db),
 841             GenericDefId::TraitId(inner) => inner.resolver(db),
 842             GenericDefId::TypeAliasId(inner) => inner.resolver(db),
 843             GenericDefId::ImplId(inner) => inner.resolver(db),
 844             GenericDefId::EnumVariantId(inner) => inner.parent.resolver(db),
 845             GenericDefId::ConstId(inner) => inner.resolver(db),
 846         }
 847     }
 848 }
 849
 850 impl HasResolver for VariantId {
 851     fn resolver(self, db: &dyn DefDatabase) -> Resolver {
 852         match self {
 853             VariantId::EnumVariantId(it) => it.parent.resolver(db),
 854             VariantId::StructId(it) => it.resolver(db),
 855             VariantId::UnionId(it) => it.resolver(db),
 856         }
 857     }
 858 }