1 //! Name resolution façade.
9 use rustc_hash::FxHashSet;
12 body::scope::{ExprScopes, ScopeId},
14 builtin_type::BuiltinType,
16 expr::{ExprId, PatId},
17 generics::GenericParams,
18 item_scope::{BuiltinShadowMode, BUILTIN_SCOPE},
20 path::{ModPath, PathKind},
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,
28 #[derive(Debug, Clone, Default)]
30 // FIXME: all usages generally call `.rev`, so maybe reverse once in construction?
34 // FIXME how to store these best
35 #[derive(Debug, Clone)]
36 struct ModuleItemMap {
37 crate_def_map: Arc<CrateDefMap>,
38 module_id: LocalModuleId,
41 #[derive(Debug, Clone)]
44 expr_scopes: Arc<ExprScopes>,
48 #[derive(Debug, Clone)]
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
56 /// Brings `Self` in enum, struct and union definitions into scope
60 /// Temporary hack to support local items.
61 LocalItemsScope(Arc<Body>),
64 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
67 GenericParam(TypeParamId),
70 // Yup, enum variants are added to the types ns, but any usage of variant as
72 EnumVariantId(EnumVariantId),
73 TypeAliasId(TypeAliasId),
74 BuiltinType(BuiltinType),
76 // Module belong to type ns, but the resolver is used when all module paths
77 // are fully resolved.
81 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
82 pub enum ResolveValueResult {
84 Partial(TypeNs, usize),
87 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
91 FunctionId(FunctionId),
95 EnumVariantId(EnumVariantId),
96 GenericParam(ConstParamId),
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()?;
104 ModuleDefId::TraitId(it) => Some(it),
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()?;
113 ModuleDefId::AdtId(AdtId::StructId(it)) => Some(it),
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()?;
122 ModuleDefId::AdtId(AdtId::EnumId(it)) => Some(it),
127 fn resolve_module_path(
129 db: &dyn DefDatabase,
131 shadow: BuiltinShadowMode,
133 let (item_map, module) = match self.module_scope() {
135 None => return PerNs::none(),
137 let (module_res, segment_index) = item_map.resolve_path(db, module, &path, shadow);
138 if segment_index.is_some() {
139 return PerNs::none();
144 pub fn resolve_module_path_in_items(&self, db: &dyn DefDatabase, path: &ModPath) -> PerNs {
145 self.resolve_module_path(db, path, BuiltinShadowMode::Module)
148 pub fn resolve_path_in_type_ns(
150 db: &dyn DefDatabase,
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() {
157 Scope::ExprScope(_) => continue,
158 Scope::GenericParams { .. }
159 | Scope::ImplDefScope(_)
160 | Scope::LocalItemsScope(_)
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) };
170 TypeNs::GenericParam(TypeParamId { local_id, parent: *def }),
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));
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));
187 Scope::ModuleScope(m) => {
188 let (module_def, idx) = m.crate_def_map.resolve_path(
192 BuiltinShadowMode::Other,
194 let res = to_type_ns(module_def)?;
195 return Some((res, idx));
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));
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),
211 ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
212 ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
214 ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
216 ModuleDefId::FunctionId(_)
217 | ModuleDefId::ConstId(_)
218 | ModuleDefId::StaticId(_)
219 | ModuleDefId::ModuleId(_) => return None,
225 pub fn resolve_path_in_type_ns_fully(
227 db: &dyn DefDatabase,
229 ) -> Option<TypeNs> {
230 let (res, unresolved) = self.resolve_path_in_type_ns(db, path)?;
231 if unresolved.is_some() {
237 pub fn resolve_visibility(
239 db: &dyn DefDatabase,
240 visibility: &RawVisibility,
241 ) -> Option<Visibility> {
243 RawVisibility::Module(_) => {
244 let (item_map, module) = match self.module_scope() {
248 item_map.resolve_visibility(db, module, visibility)
250 RawVisibility::Public => Some(Visibility::Public),
254 pub fn resolve_path_in_value_ns(
256 db: &dyn DefDatabase,
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() {
266 | Scope::ExprScope(_)
267 | Scope::GenericParams { .. }
268 | Scope::ImplDefScope(_)
269 | Scope::LocalItemsScope(_)
275 Scope::ExprScope(scope) if n_segments <= 1 => {
278 .entries(scope.scope_id)
280 .find(|entry| entry.name() == first_name);
282 if let Some(e) = entry {
283 return Some(ResolveValueResult::ValueNs(ValueNs::LocalBinding(e.pat())));
286 Scope::ExprScope(_) => continue,
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));
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));
300 Scope::GenericParams { .. } => continue,
302 Scope::ImplDefScope(impl_) => {
303 if first_name == &name![Self] {
305 let ty = TypeNs::SelfType(*impl_);
306 return Some(ResolveValueResult::Partial(ty, 1));
308 return Some(ResolveValueResult::ValueNs(ValueNs::ImplSelf(*impl_)));
312 Scope::AdtScope(adt) => {
314 // bare `Self` doesn't work in the value namespace in a struct/enum definition
317 if first_name == &name![Self] {
318 let ty = TypeNs::AdtSelfType(*adt);
319 return Some(ResolveValueResult::Partial(ty, 1));
323 Scope::ModuleScope(m) => {
324 let (module_def, idx) = m.crate_def_map.resolve_path(
328 BuiltinShadowMode::Other,
332 let value = to_value_ns(module_def)?;
333 Some(ResolveValueResult::ValueNs(value))
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),
342 ModuleDefId::ModuleId(_)
343 | ModuleDefId::FunctionId(_)
344 | ModuleDefId::EnumVariantId(_)
345 | ModuleDefId::ConstId(_)
346 | ModuleDefId::StaticId(_) => return None,
348 Some(ResolveValueResult::Partial(ty, idx))
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));
356 if let Some(res) = def {
357 return Some(ResolveValueResult::ValueNs(res));
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),
372 ModuleDefId::AdtId(AdtId::EnumId(_))
373 | ModuleDefId::AdtId(AdtId::UnionId(_))
374 | ModuleDefId::TraitId(_)
375 | ModuleDefId::TypeAliasId(_)
376 | ModuleDefId::BuiltinType(_)
377 | ModuleDefId::ModuleId(_) => return None,
383 pub fn resolve_path_in_value_ns_fully(
385 db: &dyn DefDatabase,
387 ) -> Option<ValueNs> {
388 match self.resolve_path_in_value_ns(db, path)? {
389 ResolveValueResult::ValueNs(it) => Some(it),
390 ResolveValueResult::Partial(..) => None,
394 pub fn resolve_path_as_macro(
396 db: &dyn DefDatabase,
398 ) -> Option<MacroDefId> {
399 // Search item scope legacy macro first
400 if let Some(def) = self.resolve_local_macro_def(path) {
404 let (item_map, module) = self.module_scope()?;
405 item_map.resolve_path(db, module, &path, BuiltinShadowMode::Other).0.take_macros()
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);
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());
422 traits.extend(m.crate_def_map[m.module_id].scope.traits());
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)),
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);
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 })
451 pub fn krate(&self) -> Option<CrateId> {
452 self.module_scope().map(|t| t.0.krate)
455 pub fn where_predicates_in_scope<'a>(
457 ) -> impl Iterator<Item = &'a crate::generics::WherePredicate> + 'a {
461 .filter_map(|scope| match scope {
462 Scope::GenericParams { params, .. } => Some(params),
465 .flat_map(|params| params.where_predicates.iter())
468 pub fn generic_def(&self) -> Option<GenericDefId> {
469 self.scopes.iter().rev().find_map(|scope| match scope {
470 Scope::GenericParams { def, .. } => Some(*def),
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),
485 ImplSelfType(ImplId),
487 GenericParam(TypeParamId),
492 fn process_names(&self, db: &dyn DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
493 let mut seen = FxHashSet::default();
495 Scope::ModuleScope(m) => {
496 // FIXME: should we provide `self` here?
498 // Name::self_param(),
499 // PerNs::types(Resolution::Def {
500 // def: m.module.into(),
503 m.crate_def_map[m.module_id].scope.entries().for_each(|(name, def)| {
504 f(name.clone(), ScopeDef::PerNs(def));
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));
511 m.crate_def_map.extern_prelude.iter().for_each(|(name, &def)| {
512 f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public)));
514 BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
515 f(name.clone(), ScopeDef::PerNs(def));
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));
527 Scope::LocalItemsScope(body) => body.item_scope.entries().for_each(|(name, def)| {
528 f(name.clone(), ScopeDef::PerNs(def));
530 Scope::GenericParams { params, def } => {
531 for (local_id, param) in params.types.iter() {
532 if let Some(name) = ¶m.name {
535 ScopeDef::GenericParam(TypeParamId { local_id, parent: *def }),
540 Scope::ImplDefScope(i) => {
541 f(name![Self], ScopeDef::ImplSelfType(*i));
543 Scope::AdtScope(i) => {
544 f(name![Self], ScopeDef::AdtSelfType(*i));
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()));
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))
561 pub fn resolver_for_scope(
562 db: &dyn DefDatabase,
563 owner: DefWithBodyId,
564 scope_id: Option<ScopeId>,
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);
577 fn push_scope(mut self, scope: Scope) -> Resolver {
578 self.scopes.push(scope);
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 })
587 fn push_impl_def_scope(self, impl_def: ImplId) -> Resolver {
588 self.push_scope(Scope::ImplDefScope(impl_def))
591 fn push_module_scope(
593 crate_def_map: Arc<CrateDefMap>,
594 module_id: LocalModuleId,
596 self.push_scope(Scope::ModuleScope(ModuleItemMap { crate_def_map, module_id }))
599 fn push_local_items_scope(self, body: Arc<Body>) -> Resolver {
600 self.push_scope(Scope::LocalItemsScope(body))
605 owner: DefWithBodyId,
606 expr_scopes: Arc<ExprScopes>,
609 self.push_scope(Scope::ExprScope(ExprScope { owner, expr_scopes, scope_id }))
613 pub trait HasResolver: Copy {
614 /// Builds a resolver for type references inside this def.
615 fn resolver(self, db: &dyn DefDatabase) -> Resolver;
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)
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())
631 impl<T: Into<AdtId> + Copy> HasResolver for T {
632 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
633 let def = self.into();
636 .push_generic_params_scope(db, def.into())
637 .push_scope(Scope::AdtScope(def))
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())
647 impl HasResolver for ConstId {
648 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
649 self.lookup(db).container.resolver(db)
653 impl HasResolver for StaticId {
654 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
655 self.lookup(db).container.resolver(db)
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())
665 impl HasResolver for ImplId {
666 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
670 .push_generic_params_scope(db, self.into())
671 .push_impl_def_scope(self)
675 impl HasResolver for DefWithBodyId {
676 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
678 DefWithBodyId::ConstId(c) => c.resolver(db),
679 DefWithBodyId::FunctionId(f) => f.resolver(db),
680 DefWithBodyId::StaticId(s) => s.resolver(db),
685 impl HasResolver for ContainerId {
686 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
688 ContainerId::ModuleId(it) => it.resolver(db),
689 ContainerId::DefWithBodyId(it) => it.module(db).resolver(db),
694 impl HasResolver for AssocContainerId {
695 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
697 AssocContainerId::ContainerId(it) => it.resolver(db),
698 AssocContainerId::TraitId(it) => it.resolver(db),
699 AssocContainerId::ImplId(it) => it.resolver(db),
704 impl HasResolver for GenericDefId {
705 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
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),
718 impl HasResolver for VariantId {
719 fn resolver(self, db: &dyn DefDatabase) -> Resolver {
721 VariantId::EnumVariantId(it) => it.parent.resolver(db),
722 VariantId::StructId(it) => it.resolver(db),
723 VariantId::UnionId(it) => it.resolver(db),