diff options
Diffstat (limited to 'src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs')
| -rw-r--r-- | src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs | 464 |
1 files changed, 464 insertions, 0 deletions
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs new file mode 100644 index 000000000..a11a92204 --- /dev/null +++ b/src/tools/rust-analyzer/crates/hir-def/src/item_scope.rs @@ -0,0 +1,464 @@ +//! Describes items defined or visible (ie, imported) in a certain scope. +//! This is shared between modules and blocks. + +use std::collections::hash_map::Entry; + +use base_db::CrateId; +use hir_expand::{name::Name, AstId, MacroCallId}; +use itertools::Itertools; +use once_cell::sync::Lazy; +use profile::Count; +use rustc_hash::{FxHashMap, FxHashSet}; +use smallvec::{smallvec, SmallVec}; +use stdx::format_to; +use syntax::ast; + +use crate::{ + attr::AttrId, db::DefDatabase, per_ns::PerNs, visibility::Visibility, AdtId, BuiltinType, + ConstId, HasModule, ImplId, LocalModuleId, MacroId, ModuleDefId, ModuleId, TraitId, +}; + +#[derive(Copy, Clone)] +pub(crate) enum ImportType { + Glob, + Named, +} + +#[derive(Debug, Default)] +pub struct PerNsGlobImports { + types: FxHashSet<(LocalModuleId, Name)>, + values: FxHashSet<(LocalModuleId, Name)>, + macros: FxHashSet<(LocalModuleId, Name)>, +} + +#[derive(Debug, Default, PartialEq, Eq)] +pub struct ItemScope { + _c: Count<Self>, + + /// Defs visible in this scope. This includes `declarations`, but also + /// imports. + types: FxHashMap<Name, (ModuleDefId, Visibility)>, + values: FxHashMap<Name, (ModuleDefId, Visibility)>, + macros: FxHashMap<Name, (MacroId, Visibility)>, + unresolved: FxHashSet<Name>, + + /// The defs declared in this scope. Each def has a single scope where it is + /// declared. + declarations: Vec<ModuleDefId>, + + impls: Vec<ImplId>, + unnamed_consts: Vec<ConstId>, + /// Traits imported via `use Trait as _;`. + unnamed_trait_imports: FxHashMap<TraitId, Visibility>, + /// Macros visible in current module in legacy textual scope + /// + /// For macros invoked by an unqualified identifier like `bar!()`, `legacy_macros` will be searched in first. + /// If it yields no result, then it turns to module scoped `macros`. + /// It macros with name qualified with a path like `crate::foo::bar!()`, `legacy_macros` will be skipped, + /// and only normal scoped `macros` will be searched in. + /// + /// Note that this automatically inherit macros defined textually before the definition of module itself. + /// + /// Module scoped macros will be inserted into `items` instead of here. + // FIXME: Macro shadowing in one module is not properly handled. Non-item place macros will + // be all resolved to the last one defined if shadowing happens. + legacy_macros: FxHashMap<Name, SmallVec<[MacroId; 1]>>, + /// The derive macro invocations in this scope. + attr_macros: FxHashMap<AstId<ast::Item>, MacroCallId>, + /// The derive macro invocations in this scope, keyed by the owner item over the actual derive attributes + /// paired with the derive macro invocations for the specific attribute. + derive_macros: FxHashMap<AstId<ast::Adt>, SmallVec<[DeriveMacroInvocation; 1]>>, +} + +#[derive(Debug, PartialEq, Eq)] +struct DeriveMacroInvocation { + attr_id: AttrId, + attr_call_id: MacroCallId, + derive_call_ids: SmallVec<[Option<MacroCallId>; 1]>, +} + +pub(crate) static BUILTIN_SCOPE: Lazy<FxHashMap<Name, PerNs>> = Lazy::new(|| { + BuiltinType::ALL + .iter() + .map(|(name, ty)| (name.clone(), PerNs::types((*ty).into(), Visibility::Public))) + .collect() +}); + +/// Shadow mode for builtin type which can be shadowed by module. +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub(crate) enum BuiltinShadowMode { + /// Prefer user-defined modules (or other types) over builtins. + Module, + /// Prefer builtins over user-defined modules (but not other types). + Other, +} + +/// Legacy macros can only be accessed through special methods like `get_legacy_macros`. +/// Other methods will only resolve values, types and module scoped macros only. +impl ItemScope { + pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, PerNs)> + 'a { + // FIXME: shadowing + self.types + .keys() + .chain(self.values.keys()) + .chain(self.macros.keys()) + .chain(self.unresolved.iter()) + .sorted() + .unique() + .map(move |name| (name, self.get(name))) + } + + pub fn declarations(&self) -> impl Iterator<Item = ModuleDefId> + '_ { + self.declarations.iter().copied() + } + + pub fn impls(&self) -> impl Iterator<Item = ImplId> + ExactSizeIterator + '_ { + self.impls.iter().copied() + } + + pub fn values( + &self, + ) -> impl Iterator<Item = (ModuleDefId, Visibility)> + ExactSizeIterator + '_ { + self.values.values().copied() + } + + pub fn types( + &self, + ) -> impl Iterator<Item = (ModuleDefId, Visibility)> + ExactSizeIterator + '_ { + self.types.values().copied() + } + + pub fn unnamed_consts(&self) -> impl Iterator<Item = ConstId> + '_ { + self.unnamed_consts.iter().copied() + } + + /// Iterate over all module scoped macros + pub(crate) fn macros(&self) -> impl Iterator<Item = (&Name, MacroId)> + '_ { + self.entries().filter_map(|(name, def)| def.take_macros().map(|macro_| (name, macro_))) + } + + /// Iterate over all legacy textual scoped macros visible at the end of the module + pub fn legacy_macros(&self) -> impl Iterator<Item = (&Name, &[MacroId])> + '_ { + self.legacy_macros.iter().map(|(name, def)| (name, &**def)) + } + + /// Get a name from current module scope, legacy macros are not included + pub(crate) fn get(&self, name: &Name) -> PerNs { + PerNs { + types: self.types.get(name).copied(), + values: self.values.get(name).copied(), + macros: self.macros.get(name).copied(), + } + } + + pub(crate) fn type_(&self, name: &Name) -> Option<(ModuleDefId, Visibility)> { + self.types.get(name).copied() + } + + /// XXX: this is O(N) rather than O(1), try to not introduce new usages. + pub(crate) fn name_of(&self, item: ItemInNs) -> Option<(&Name, Visibility)> { + let (def, mut iter) = match item { + ItemInNs::Macros(def) => { + return self + .macros + .iter() + .find_map(|(name, &(other_def, vis))| (other_def == def).then(|| (name, vis))); + } + ItemInNs::Types(def) => (def, self.types.iter()), + ItemInNs::Values(def) => (def, self.values.iter()), + }; + iter.find_map(|(name, &(other_def, vis))| (other_def == def).then(|| (name, vis))) + } + + pub(crate) fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a { + self.types + .values() + .filter_map(|&(def, _)| match def { + ModuleDefId::TraitId(t) => Some(t), + _ => None, + }) + .chain(self.unnamed_trait_imports.keys().copied()) + } + + pub(crate) fn declare(&mut self, def: ModuleDefId) { + self.declarations.push(def) + } + + pub(crate) fn get_legacy_macro(&self, name: &Name) -> Option<&[MacroId]> { + self.legacy_macros.get(name).map(|it| &**it) + } + + pub(crate) fn define_impl(&mut self, imp: ImplId) { + self.impls.push(imp) + } + + pub(crate) fn define_unnamed_const(&mut self, konst: ConstId) { + self.unnamed_consts.push(konst); + } + + pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroId) { + self.legacy_macros.entry(name).or_default().push(mac); + } + + pub(crate) fn add_attr_macro_invoc(&mut self, item: AstId<ast::Item>, call: MacroCallId) { + self.attr_macros.insert(item, call); + } + + pub(crate) fn attr_macro_invocs( + &self, + ) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ { + self.attr_macros.iter().map(|(k, v)| (*k, *v)) + } + + pub(crate) fn set_derive_macro_invoc( + &mut self, + adt: AstId<ast::Adt>, + call: MacroCallId, + id: AttrId, + idx: usize, + ) { + if let Some(derives) = self.derive_macros.get_mut(&adt) { + if let Some(DeriveMacroInvocation { derive_call_ids, .. }) = + derives.iter_mut().find(|&&mut DeriveMacroInvocation { attr_id, .. }| id == attr_id) + { + derive_call_ids[idx] = Some(call); + } + } + } + + /// We are required to set this up front as derive invocation recording happens out of order + /// due to the fixed pointer iteration loop being able to record some derives later than others + /// independent of their indices. + pub(crate) fn init_derive_attribute( + &mut self, + adt: AstId<ast::Adt>, + attr_id: AttrId, + attr_call_id: MacroCallId, + len: usize, + ) { + self.derive_macros.entry(adt).or_default().push(DeriveMacroInvocation { + attr_id, + attr_call_id, + derive_call_ids: smallvec![None; len], + }); + } + + pub(crate) fn derive_macro_invocs( + &self, + ) -> impl Iterator< + Item = ( + AstId<ast::Adt>, + impl Iterator<Item = (AttrId, MacroCallId, &[Option<MacroCallId>])>, + ), + > + '_ { + self.derive_macros.iter().map(|(k, v)| { + ( + *k, + v.iter().map(|DeriveMacroInvocation { attr_id, attr_call_id, derive_call_ids }| { + (*attr_id, *attr_call_id, &**derive_call_ids) + }), + ) + }) + } + + pub(crate) fn unnamed_trait_vis(&self, tr: TraitId) -> Option<Visibility> { + self.unnamed_trait_imports.get(&tr).copied() + } + + pub(crate) fn push_unnamed_trait(&mut self, tr: TraitId, vis: Visibility) { + self.unnamed_trait_imports.insert(tr, vis); + } + + pub(crate) fn push_res_with_import( + &mut self, + glob_imports: &mut PerNsGlobImports, + lookup: (LocalModuleId, Name), + def: PerNs, + def_import_type: ImportType, + ) -> bool { + let mut changed = false; + + macro_rules! check_changed { + ( + $changed:ident, + ( $this:ident / $def:ident ) . $field:ident, + $glob_imports:ident [ $lookup:ident ], + $def_import_type:ident + ) => {{ + if let Some(fld) = $def.$field { + let existing = $this.$field.entry($lookup.1.clone()); + match existing { + Entry::Vacant(entry) => { + match $def_import_type { + ImportType::Glob => { + $glob_imports.$field.insert($lookup.clone()); + } + ImportType::Named => { + $glob_imports.$field.remove(&$lookup); + } + } + + entry.insert(fld); + $changed = true; + } + Entry::Occupied(mut entry) + if $glob_imports.$field.contains(&$lookup) + && matches!($def_import_type, ImportType::Named) => + { + cov_mark::hit!(import_shadowed); + $glob_imports.$field.remove(&$lookup); + entry.insert(fld); + $changed = true; + } + _ => {} + } + } + }}; + } + + check_changed!(changed, (self / def).types, glob_imports[lookup], def_import_type); + check_changed!(changed, (self / def).values, glob_imports[lookup], def_import_type); + check_changed!(changed, (self / def).macros, glob_imports[lookup], def_import_type); + + if def.is_none() && self.unresolved.insert(lookup.1) { + changed = true; + } + + changed + } + + pub(crate) fn resolutions<'a>(&'a self) -> impl Iterator<Item = (Option<Name>, PerNs)> + 'a { + self.entries().map(|(name, res)| (Some(name.clone()), res)).chain( + self.unnamed_trait_imports + .iter() + .map(|(tr, vis)| (None, PerNs::types(ModuleDefId::TraitId(*tr), *vis))), + ) + } + + pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, SmallVec<[MacroId; 1]>> { + self.legacy_macros.clone() + } + + /// Marks everything that is not a procedural macro as private to `this_module`. + pub(crate) fn censor_non_proc_macros(&mut self, this_module: ModuleId) { + self.types + .values_mut() + .chain(self.values.values_mut()) + .map(|(_, v)| v) + .chain(self.unnamed_trait_imports.values_mut()) + .for_each(|vis| *vis = Visibility::Module(this_module)); + + for (mac, vis) in self.macros.values_mut() { + if let MacroId::ProcMacroId(_) = mac { + // FIXME: Technically this is insufficient since reexports of proc macros are also + // forbidden. Practically nobody does that. + continue; + } + + *vis = Visibility::Module(this_module); + } + } + + pub(crate) fn dump(&self, buf: &mut String) { + let mut entries: Vec<_> = self.resolutions().collect(); + entries.sort_by_key(|(name, _)| name.clone()); + + for (name, def) in entries { + format_to!(buf, "{}:", name.map_or("_".to_string(), |name| name.to_string())); + + if def.types.is_some() { + buf.push_str(" t"); + } + if def.values.is_some() { + buf.push_str(" v"); + } + if def.macros.is_some() { + buf.push_str(" m"); + } + if def.is_none() { + buf.push_str(" _"); + } + + buf.push('\n'); + } + } + + pub(crate) fn shrink_to_fit(&mut self) { + // Exhaustive match to require handling new fields. + let Self { + _c: _, + types, + values, + macros, + unresolved, + declarations, + impls, + unnamed_consts, + unnamed_trait_imports, + legacy_macros, + attr_macros, + derive_macros, + } = self; + types.shrink_to_fit(); + values.shrink_to_fit(); + macros.shrink_to_fit(); + unresolved.shrink_to_fit(); + declarations.shrink_to_fit(); + impls.shrink_to_fit(); + unnamed_consts.shrink_to_fit(); + unnamed_trait_imports.shrink_to_fit(); + legacy_macros.shrink_to_fit(); + attr_macros.shrink_to_fit(); + derive_macros.shrink_to_fit(); + } +} + +impl PerNs { + pub(crate) fn from_def(def: ModuleDefId, v: Visibility, has_constructor: bool) -> PerNs { + match def { + ModuleDefId::ModuleId(_) => PerNs::types(def, v), + ModuleDefId::FunctionId(_) => PerNs::values(def, v), + ModuleDefId::AdtId(adt) => match adt { + AdtId::UnionId(_) => PerNs::types(def, v), + AdtId::EnumId(_) => PerNs::types(def, v), + AdtId::StructId(_) => { + if has_constructor { + PerNs::both(def, def, v) + } else { + PerNs::types(def, v) + } + } + }, + ModuleDefId::EnumVariantId(_) => PerNs::both(def, def, v), + ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def, v), + ModuleDefId::TraitId(_) => PerNs::types(def, v), + ModuleDefId::TypeAliasId(_) => PerNs::types(def, v), + ModuleDefId::BuiltinType(_) => PerNs::types(def, v), + ModuleDefId::MacroId(mac) => PerNs::macros(mac, v), + } + } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] +pub enum ItemInNs { + Types(ModuleDefId), + Values(ModuleDefId), + Macros(MacroId), +} + +impl ItemInNs { + pub fn as_module_def_id(self) -> Option<ModuleDefId> { + match self { + ItemInNs::Types(id) | ItemInNs::Values(id) => Some(id), + ItemInNs::Macros(_) => None, + } + } + + /// Returns the crate defining this item (or `None` if `self` is built-in). + pub fn krate(&self, db: &dyn DefDatabase) -> Option<CrateId> { + match self { + ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate), + ItemInNs::Macros(id) => Some(id.module(db).krate), + } + } +} |