1 //! Describes items defined or visible (ie, imported) in a certain scope.
2 //! This is shared between modules and blocks.
4 use std::collections::hash_map::Entry;
7 use hir_expand::name::Name;
8 use hir_expand::MacroDefKind;
9 use once_cell::sync::Lazy;
10 use rustc_hash::{FxHashMap, FxHashSet};
15 db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, HasModule, ImplId,
16 LocalModuleId, Lookup, MacroDefId, ModuleDefId, TraitId,
19 #[derive(Copy, Clone)]
20 pub(crate) enum ImportType {
25 #[derive(Debug, Default)]
26 pub struct PerNsGlobImports {
27 types: FxHashSet<(LocalModuleId, Name)>,
28 values: FxHashSet<(LocalModuleId, Name)>,
29 macros: FxHashSet<(LocalModuleId, Name)>,
32 #[derive(Debug, Default, PartialEq, Eq)]
33 pub struct ItemScope {
34 types: FxHashMap<Name, (ModuleDefId, Visibility)>,
35 values: FxHashMap<Name, (ModuleDefId, Visibility)>,
36 macros: FxHashMap<Name, (MacroDefId, Visibility)>,
37 unresolved: FxHashSet<Name>,
39 defs: Vec<ModuleDefId>,
41 /// Traits imported via `use Trait as _;`.
42 unnamed_trait_imports: FxHashMap<TraitId, Visibility>,
43 /// Macros visible in current module in legacy textual scope
45 /// For macros invoked by an unqualified identifier like `bar!()`, `legacy_macros` will be searched in first.
46 /// If it yields no result, then it turns to module scoped `macros`.
47 /// It macros with name qualified with a path like `crate::foo::bar!()`, `legacy_macros` will be skipped,
48 /// and only normal scoped `macros` will be searched in.
50 /// Note that this automatically inherit macros defined textually before the definition of module itself.
52 /// Module scoped macros will be inserted into `items` instead of here.
53 // FIXME: Macro shadowing in one module is not properly handled. Non-item place macros will
54 // be all resolved to the last one defined if shadowing happens.
55 legacy_macros: FxHashMap<Name, MacroDefId>,
58 pub(crate) static BUILTIN_SCOPE: Lazy<FxHashMap<Name, PerNs>> = Lazy::new(|| {
61 .map(|(name, ty)| (name.clone(), PerNs::types(ty.clone().into(), Visibility::Public)))
65 /// Shadow mode for builtin type which can be shadowed by module.
66 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
67 pub(crate) enum BuiltinShadowMode {
68 /// Prefer user-defined modules (or other types) over builtins.
70 /// Prefer builtins over user-defined modules (but not other types).
74 /// Legacy macros can only be accessed through special methods like `get_legacy_macros`.
75 /// Other methods will only resolve values, types and module scoped macros only.
77 pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, PerNs)> + 'a {
79 let keys: FxHashSet<_> = self
82 .chain(self.values.keys())
83 .chain(self.macros.keys())
84 .chain(self.unresolved.iter())
87 keys.into_iter().map(move |name| (name, self.get(name)))
90 pub fn declarations(&self) -> impl Iterator<Item = ModuleDefId> + '_ {
91 self.defs.iter().copied()
94 pub fn impls(&self) -> impl Iterator<Item = ImplId> + ExactSizeIterator + '_ {
95 self.impls.iter().copied()
100 ) -> impl Iterator<Item = (ModuleDefId, Visibility)> + ExactSizeIterator + '_ {
101 self.values.values().copied()
104 pub fn visibility_of(&self, def: ModuleDefId) -> Option<Visibility> {
105 self.name_of(ItemInNs::Types(def))
106 .or_else(|| self.name_of(ItemInNs::Values(def)))
110 /// Iterate over all module scoped macros
111 pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
112 self.entries().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_)))
115 /// Iterate over all legacy textual scoped macros visible at the end of the module
116 pub(crate) fn legacy_macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
117 self.legacy_macros.iter().map(|(name, def)| (name, *def))
120 /// Get a name from current module scope, legacy macros are not included
121 pub(crate) fn get(&self, name: &Name) -> PerNs {
123 types: self.types.get(name).copied(),
124 values: self.values.get(name).copied(),
125 macros: self.macros.get(name).copied(),
129 pub(crate) fn name_of(&self, item: ItemInNs) -> Option<(&Name, Visibility)> {
130 for (name, per_ns) in self.entries() {
131 if let Some(vis) = item.match_with(per_ns) {
132 return Some((name, vis));
138 pub(crate) fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a {
141 .filter_map(|(def, _)| match def {
142 ModuleDefId::TraitId(t) => Some(*t),
145 .chain(self.unnamed_trait_imports.keys().copied())
148 pub(crate) fn define_def(&mut self, def: ModuleDefId) {
152 pub(crate) fn get_legacy_macro(&self, name: &Name) -> Option<MacroDefId> {
153 self.legacy_macros.get(name).copied()
156 pub(crate) fn define_impl(&mut self, imp: ImplId) {
160 pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroDefId) {
161 self.legacy_macros.insert(name, mac);
164 pub(crate) fn unnamed_trait_vis(&self, tr: TraitId) -> Option<Visibility> {
165 self.unnamed_trait_imports.get(&tr).copied()
168 pub(crate) fn push_unnamed_trait(&mut self, tr: TraitId, vis: Visibility) {
169 self.unnamed_trait_imports.insert(tr, vis);
172 pub(crate) fn push_res(&mut self, name: Name, def: PerNs) -> bool {
173 let mut changed = false;
175 if let Some(types) = def.types {
176 self.types.entry(name.clone()).or_insert_with(|| {
181 if let Some(values) = def.values {
182 self.values.entry(name.clone()).or_insert_with(|| {
187 if let Some(macros) = def.macros {
188 self.macros.entry(name.clone()).or_insert_with(|| {
195 if self.unresolved.insert(name) {
203 pub(crate) fn push_res_with_import(
205 glob_imports: &mut PerNsGlobImports,
206 lookup: (LocalModuleId, Name),
208 def_import_type: ImportType,
210 let mut changed = false;
212 macro_rules! check_changed {
215 ( $this:ident / $def:ident ) . $field:ident,
216 $glob_imports:ident [ $lookup:ident ],
217 $def_import_type:ident
219 let existing = $this.$field.entry($lookup.1.clone());
220 match (existing, $def.$field) {
221 (Entry::Vacant(entry), Some(_)) => {
222 match $def_import_type {
223 ImportType::Glob => {
224 $glob_imports.$field.insert($lookup.clone());
226 ImportType::Named => {
227 $glob_imports.$field.remove(&$lookup);
231 if let Some(fld) = $def.$field {
236 (Entry::Occupied(mut entry), Some(_))
237 if $glob_imports.$field.contains(&$lookup)
238 && matches!($def_import_type, ImportType::Named) =>
240 mark::hit!(import_shadowed);
241 $glob_imports.$field.remove(&$lookup);
242 if let Some(fld) = $def.$field {
252 check_changed!(changed, (self / def).types, glob_imports[lookup], def_import_type);
253 check_changed!(changed, (self / def).values, glob_imports[lookup], def_import_type);
254 check_changed!(changed, (self / def).macros, glob_imports[lookup], def_import_type);
257 if self.unresolved.insert(lookup.1) {
265 pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Option<Name>, PerNs)> + 'a {
266 self.entries().map(|(name, res)| (Some(name.clone()), res)).chain(
267 self.unnamed_trait_imports
269 .map(|(tr, vis)| (None, PerNs::types(ModuleDefId::TraitId(*tr), *vis))),
273 pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> {
274 self.legacy_macros.clone()
277 /// Marks everything that is not a procedural macro as private to `this_module`.
278 pub(crate) fn censor_non_proc_macros(&mut self, this_module: ModuleId) {
281 .chain(self.values.values_mut())
283 .chain(self.unnamed_trait_imports.values_mut())
284 .for_each(|vis| *vis = Visibility::Module(this_module));
286 for (mac, vis) in self.macros.values_mut() {
287 if let MacroDefKind::ProcMacro(_) = mac.kind {
288 // FIXME: Technically this is insufficient since reexports of proc macros are also
289 // forbidden. Practically nobody does that.
293 *vis = Visibility::Module(this_module);
299 pub(crate) fn from_def(def: ModuleDefId, v: Visibility, has_constructor: bool) -> PerNs {
301 ModuleDefId::ModuleId(_) => PerNs::types(def, v),
302 ModuleDefId::FunctionId(_) => PerNs::values(def, v),
303 ModuleDefId::AdtId(adt) => match adt {
304 AdtId::UnionId(_) => PerNs::types(def, v),
305 AdtId::EnumId(_) => PerNs::types(def, v),
306 AdtId::StructId(_) => {
308 PerNs::both(def, def, v)
314 ModuleDefId::EnumVariantId(_) => PerNs::both(def, def, v),
315 ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def, v),
316 ModuleDefId::TraitId(_) => PerNs::types(def, v),
317 ModuleDefId::TypeAliasId(_) => PerNs::types(def, v),
318 ModuleDefId::BuiltinType(_) => PerNs::types(def, v),
323 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
331 fn match_with(self, per_ns: PerNs) -> Option<Visibility> {
333 ItemInNs::Types(def) => {
334 per_ns.types.filter(|(other_def, _)| *other_def == def).map(|(_, vis)| vis)
336 ItemInNs::Values(def) => {
337 per_ns.values.filter(|(other_def, _)| *other_def == def).map(|(_, vis)| vis)
339 ItemInNs::Macros(def) => {
340 per_ns.macros.filter(|(other_def, _)| *other_def == def).map(|(_, vis)| vis)
345 pub fn as_module_def_id(self) -> Option<ModuleDefId> {
347 ItemInNs::Types(id) | ItemInNs::Values(id) => Some(id),
348 ItemInNs::Macros(_) => None,
352 /// Returns the crate defining this item (or `None` if `self` is built-in).
353 pub fn krate(&self, db: &dyn DefDatabase) -> Option<CrateId> {
355 ItemInNs::Types(did) | ItemInNs::Values(did) => match did {
356 ModuleDefId::ModuleId(id) => id.krate,
357 ModuleDefId::FunctionId(id) => id.lookup(db).module(db).krate,
358 ModuleDefId::AdtId(id) => id.module(db).krate,
359 ModuleDefId::EnumVariantId(id) => id.parent.lookup(db).container.module(db).krate,
360 ModuleDefId::ConstId(id) => id.lookup(db).container.module(db).krate,
361 ModuleDefId::StaticId(id) => id.lookup(db).container.module(db).krate,
362 ModuleDefId::TraitId(id) => id.lookup(db).container.module(db).krate,
363 ModuleDefId::TypeAliasId(id) => id.lookup(db).module(db).krate,
364 ModuleDefId::BuiltinType(_) => return None,
366 ItemInNs::Macros(id) => return Some(id.krate),