diff options
Diffstat (limited to 'crates/ra_hir_def/src/item_scope.rs')
-rw-r--r-- | crates/ra_hir_def/src/item_scope.rs | 165 |
1 files changed, 165 insertions, 0 deletions
diff --git a/crates/ra_hir_def/src/item_scope.rs b/crates/ra_hir_def/src/item_scope.rs new file mode 100644 index 000000000..6b9be8325 --- /dev/null +++ b/crates/ra_hir_def/src/item_scope.rs | |||
@@ -0,0 +1,165 @@ | |||
1 | //! Describes items defined or visible (ie, imported) in a certain scope. | ||
2 | //! This is shared between modules and blocks. | ||
3 | |||
4 | use hir_expand::name::Name; | ||
5 | use once_cell::sync::Lazy; | ||
6 | use rustc_hash::FxHashMap; | ||
7 | |||
8 | use crate::{per_ns::PerNs, BuiltinType, ImplId, LocalImportId, MacroDefId, ModuleDefId, TraitId}; | ||
9 | |||
10 | #[derive(Debug, Default, PartialEq, Eq)] | ||
11 | pub struct ItemScope { | ||
12 | items: FxHashMap<Name, Resolution>, | ||
13 | impls: Vec<ImplId>, | ||
14 | /// Macros visible in current module in legacy textual scope | ||
15 | /// | ||
16 | /// For macros invoked by an unqualified identifier like `bar!()`, `legacy_macros` will be searched in first. | ||
17 | /// If it yields no result, then it turns to module scoped `macros`. | ||
18 | /// It macros with name qualified with a path like `crate::foo::bar!()`, `legacy_macros` will be skipped, | ||
19 | /// and only normal scoped `macros` will be searched in. | ||
20 | /// | ||
21 | /// Note that this automatically inherit macros defined textually before the definition of module itself. | ||
22 | /// | ||
23 | /// Module scoped macros will be inserted into `items` instead of here. | ||
24 | // FIXME: Macro shadowing in one module is not properly handled. Non-item place macros will | ||
25 | // be all resolved to the last one defined if shadowing happens. | ||
26 | legacy_macros: FxHashMap<Name, MacroDefId>, | ||
27 | } | ||
28 | |||
29 | static BUILTIN_SCOPE: Lazy<FxHashMap<Name, Resolution>> = Lazy::new(|| { | ||
30 | BuiltinType::ALL | ||
31 | .iter() | ||
32 | .map(|(name, ty)| { | ||
33 | (name.clone(), Resolution { def: PerNs::types(ty.clone().into()), import: None }) | ||
34 | }) | ||
35 | .collect() | ||
36 | }); | ||
37 | |||
38 | /// Shadow mode for builtin type which can be shadowed by module. | ||
39 | #[derive(Debug, Copy, Clone, PartialEq, Eq)] | ||
40 | pub(crate) enum BuiltinShadowMode { | ||
41 | // Prefer Module | ||
42 | Module, | ||
43 | // Prefer Other Types | ||
44 | Other, | ||
45 | } | ||
46 | |||
47 | /// Legacy macros can only be accessed through special methods like `get_legacy_macros`. | ||
48 | /// Other methods will only resolve values, types and module scoped macros only. | ||
49 | impl ItemScope { | ||
50 | pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, &'a Resolution)> + 'a { | ||
51 | //FIXME: shadowing | ||
52 | self.items.iter().chain(BUILTIN_SCOPE.iter()) | ||
53 | } | ||
54 | |||
55 | pub fn declarations(&self) -> impl Iterator<Item = ModuleDefId> + '_ { | ||
56 | self.entries() | ||
57 | .filter_map(|(_name, res)| if res.import.is_none() { Some(res.def) } else { None }) | ||
58 | .flat_map(|per_ns| { | ||
59 | per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter()) | ||
60 | }) | ||
61 | } | ||
62 | |||
63 | pub fn impls(&self) -> impl Iterator<Item = ImplId> + ExactSizeIterator + '_ { | ||
64 | self.impls.iter().copied() | ||
65 | } | ||
66 | |||
67 | /// Iterate over all module scoped macros | ||
68 | pub(crate) fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a { | ||
69 | self.items | ||
70 | .iter() | ||
71 | .filter_map(|(name, res)| res.def.take_macros().map(|macro_| (name, macro_))) | ||
72 | } | ||
73 | |||
74 | /// Iterate over all legacy textual scoped macros visible at the end of the module | ||
75 | pub(crate) fn legacy_macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a { | ||
76 | self.legacy_macros.iter().map(|(name, def)| (name, *def)) | ||
77 | } | ||
78 | |||
79 | /// Get a name from current module scope, legacy macros are not included | ||
80 | pub(crate) fn get(&self, name: &Name, shadow: BuiltinShadowMode) -> Option<&Resolution> { | ||
81 | match shadow { | ||
82 | BuiltinShadowMode::Module => self.items.get(name).or_else(|| BUILTIN_SCOPE.get(name)), | ||
83 | BuiltinShadowMode::Other => { | ||
84 | let item = self.items.get(name); | ||
85 | if let Some(res) = item { | ||
86 | if let Some(ModuleDefId::ModuleId(_)) = res.def.take_types() { | ||
87 | return BUILTIN_SCOPE.get(name).or(item); | ||
88 | } | ||
89 | } | ||
90 | |||
91 | item.or_else(|| BUILTIN_SCOPE.get(name)) | ||
92 | } | ||
93 | } | ||
94 | } | ||
95 | |||
96 | pub(crate) fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a { | ||
97 | self.items.values().filter_map(|r| match r.def.take_types() { | ||
98 | Some(ModuleDefId::TraitId(t)) => Some(t), | ||
99 | _ => None, | ||
100 | }) | ||
101 | } | ||
102 | |||
103 | pub(crate) fn get_legacy_macro(&self, name: &Name) -> Option<MacroDefId> { | ||
104 | self.legacy_macros.get(name).copied() | ||
105 | } | ||
106 | |||
107 | pub(crate) fn define_impl(&mut self, imp: ImplId) { | ||
108 | self.impls.push(imp) | ||
109 | } | ||
110 | |||
111 | pub(crate) fn define_legacy_macro(&mut self, name: Name, mac: MacroDefId) { | ||
112 | self.legacy_macros.insert(name, mac); | ||
113 | } | ||
114 | |||
115 | pub(crate) fn push_res( | ||
116 | &mut self, | ||
117 | name: Name, | ||
118 | res: &Resolution, | ||
119 | import: Option<LocalImportId>, | ||
120 | ) -> bool { | ||
121 | let mut changed = false; | ||
122 | let existing = self.items.entry(name.clone()).or_default(); | ||
123 | |||
124 | if existing.def.types.is_none() && res.def.types.is_some() { | ||
125 | existing.def.types = res.def.types; | ||
126 | existing.import = import.or(res.import); | ||
127 | changed = true; | ||
128 | } | ||
129 | if existing.def.values.is_none() && res.def.values.is_some() { | ||
130 | existing.def.values = res.def.values; | ||
131 | existing.import = import.or(res.import); | ||
132 | changed = true; | ||
133 | } | ||
134 | if existing.def.macros.is_none() && res.def.macros.is_some() { | ||
135 | existing.def.macros = res.def.macros; | ||
136 | existing.import = import.or(res.import); | ||
137 | changed = true; | ||
138 | } | ||
139 | |||
140 | if existing.def.is_none() | ||
141 | && res.def.is_none() | ||
142 | && existing.import.is_none() | ||
143 | && res.import.is_some() | ||
144 | { | ||
145 | existing.import = res.import; | ||
146 | } | ||
147 | changed | ||
148 | } | ||
149 | |||
150 | pub(crate) fn collect_resolutions(&self) -> Vec<(Name, Resolution)> { | ||
151 | self.items.iter().map(|(name, res)| (name.clone(), res.clone())).collect() | ||
152 | } | ||
153 | |||
154 | pub(crate) fn collect_legacy_macros(&self) -> FxHashMap<Name, MacroDefId> { | ||
155 | self.legacy_macros.clone() | ||
156 | } | ||
157 | } | ||
158 | |||
159 | #[derive(Debug, Clone, PartialEq, Eq, Default)] | ||
160 | pub struct Resolution { | ||
161 | /// None for unresolved | ||
162 | pub def: PerNs, | ||
163 | /// ident by which this is imported into local scope. | ||
164 | pub import: Option<LocalImportId>, | ||
165 | } | ||