1use crate::{DeclId, ModuleId, OverlayId, Span, TypeAliasId, VarId};
2use rustc_hash::FxBuildHasher;
3use std::{
4 collections::HashMap,
5 ops::Deref,
6 sync::atomic::{AtomicUsize, Ordering},
7};
8
9static LONGEST_DECL_NAME: AtomicUsize = AtomicUsize::new(0);
11
12pub fn longest_decl_name() -> usize {
21 LONGEST_DECL_NAME.load(Ordering::Relaxed)
22}
23
24#[derive(Debug, Clone, Default)]
43pub struct DeclNameMap {
44 map: HashMap<Vec<u8>, DeclId, FxBuildHasher>,
45 longest_name: usize,
46}
47
48impl DeclNameMap {
49 pub fn new() -> Self {
50 Self::default()
51 }
52
53 pub fn get(&self, name: &[u8]) -> Option<&DeclId> {
56 if name.len() > self.longest_name {
57 return None;
58 }
59 self.map.get(name)
60 }
61
62 pub fn insert(&mut self, name: Vec<u8>, decl_id: DeclId) -> Option<DeclId> {
63 self.longest_name = self.longest_name.max(name.len());
64 LONGEST_DECL_NAME.fetch_max(name.len(), Ordering::Relaxed);
65 self.map.insert(name, decl_id)
66 }
67
68 pub fn remove(&mut self, name: &[u8]) -> Option<DeclId> {
69 self.map.remove(name)
70 }
71
72 pub fn remove_entry(&mut self, name: &[u8]) -> Option<(Vec<u8>, DeclId)> {
73 self.map.remove_entry(name)
74 }
75}
76
77impl Deref for DeclNameMap {
78 type Target = HashMap<Vec<u8>, DeclId, FxBuildHasher>;
79
80 fn deref(&self) -> &Self::Target {
81 &self.map
82 }
83}
84
85impl<'a> IntoIterator for &'a DeclNameMap {
86 type Item = (&'a Vec<u8>, &'a DeclId);
87 type IntoIter = std::collections::hash_map::Iter<'a, Vec<u8>, DeclId>;
88
89 fn into_iter(self) -> Self::IntoIter {
90 self.map.iter()
91 }
92}
93
94impl IntoIterator for DeclNameMap {
95 type Item = (Vec<u8>, DeclId);
96 type IntoIter = std::collections::hash_map::IntoIter<Vec<u8>, DeclId>;
97
98 fn into_iter(self) -> Self::IntoIter {
99 self.map.into_iter()
100 }
101}
102
103impl Extend<(Vec<u8>, DeclId)> for DeclNameMap {
104 fn extend<I: IntoIterator<Item = (Vec<u8>, DeclId)>>(&mut self, iter: I) {
105 for (name, decl_id) in iter {
106 self.insert(name, decl_id);
107 }
108 }
109}
110
111impl FromIterator<(Vec<u8>, DeclId)> for DeclNameMap {
112 fn from_iter<I: IntoIterator<Item = (Vec<u8>, DeclId)>>(iter: I) -> Self {
113 let mut map = Self::default();
114 map.extend(iter);
115 map
116 }
117}
118
119pub static DEFAULT_OVERLAY_NAME: &str = "zero";
120
121#[derive(Debug, Clone)]
126pub struct Visibility {
127 decl_ids: HashMap<DeclId, bool, FxBuildHasher>,
128 type_alias_ids: HashMap<TypeAliasId, bool, FxBuildHasher>,
130}
131
132#[derive(Debug, Clone, Default)]
142pub struct BoundNames {
143 pub decls: Vec<(Vec<u8>, DeclId)>,
144 pub modules: Vec<(Vec<u8>, ModuleId)>,
145 pub vars: Vec<(Vec<u8>, VarId)>,
146 pub type_aliases: Vec<(Vec<u8>, TypeAliasId)>,
147}
148
149#[derive(Debug, Clone, Default)]
164pub struct ScopeBindings {
165 pub decls: HashMap<Vec<u8>, DeclId>,
166 pub modules: HashMap<Vec<u8>, ModuleId>,
167 pub visibility: Visibility,
168}
169
170impl ScopeBindings {
171 pub fn is_empty(&self) -> bool {
172 self.decls.is_empty() && self.modules.is_empty() && self.visibility.decl_ids.is_empty()
173 }
174
175 pub fn extend_from_overlay(&mut self, overlay: &OverlayFrame) {
177 self.decls
178 .extend(overlay.decls.iter().map(|(k, v)| (k.clone(), *v)));
179 self.modules
180 .extend(overlay.modules.iter().map(|(k, v)| (k.clone(), *v)));
181 self.visibility.merge_with(overlay.visibility.clone());
182 }
183
184 pub fn extend_from_bindings(&mut self, other: &ScopeBindings) {
186 self.decls
187 .extend(other.decls.iter().map(|(k, v)| (k.clone(), *v)));
188 self.modules
189 .extend(other.modules.iter().map(|(k, v)| (k.clone(), *v)));
190 self.visibility.merge_with(other.visibility.clone());
191 }
192}
193
194impl Visibility {
195 pub fn new() -> Self {
196 Visibility {
197 decl_ids: HashMap::default(),
198 type_alias_ids: HashMap::default(),
199 }
200 }
201
202 pub fn is_decl_id_visible(&self, decl_id: &DeclId) -> bool {
203 *self.decl_ids.get(decl_id).unwrap_or(&true) }
205
206 pub fn hide_decl_id(&mut self, decl_id: &DeclId) {
207 self.decl_ids.insert(*decl_id, false);
208 }
209
210 pub fn use_decl_id(&mut self, decl_id: &DeclId) {
211 self.decl_ids.insert(*decl_id, true);
212 }
213
214 pub fn is_type_alias_id_visible(&self, type_alias_id: &TypeAliasId) -> bool {
215 *self.type_alias_ids.get(type_alias_id).unwrap_or(&true) }
217
218 pub fn hide_type_alias_id(&mut self, type_alias_id: &TypeAliasId) {
219 self.type_alias_ids.insert(*type_alias_id, false);
220 }
221
222 pub fn use_type_alias_id(&mut self, type_alias_id: &TypeAliasId) {
223 self.type_alias_ids.insert(*type_alias_id, true);
224 }
225
226 pub fn merge_with(&mut self, other: Visibility) {
228 self.decl_ids.extend(other.decl_ids);
229 self.type_alias_ids.extend(other.type_alias_ids);
230 }
231
232 pub fn append(&mut self, other: &Visibility) {
234 for (decl_id, visible) in other.decl_ids.iter() {
235 if !self.decl_ids.contains_key(decl_id) {
236 self.decl_ids.insert(*decl_id, *visible);
237 }
238 }
239 for (type_alias_id, visible) in other.type_alias_ids.iter() {
240 self.type_alias_ids
241 .entry(*type_alias_id)
242 .or_insert(*visible);
243 }
244 }
245
246 pub fn hides_more_than(&self, before: &Visibility) -> bool {
248 self.decl_ids
249 .iter()
250 .any(|(id, visible)| !visible && before.decl_ids.get(id) != Some(&false))
251 || self
252 .type_alias_ids
253 .iter()
254 .any(|(id, visible)| !visible && before.type_alias_ids.get(id) != Some(&false))
255 }
256}
257
258#[derive(Debug, Default)]
267pub struct VisibilityStack<'a> {
268 inline: [Option<&'a Visibility>; 4],
272 spilled: Vec<&'a Visibility>,
274}
275
276impl<'a> VisibilityStack<'a> {
277 pub fn push(&mut self, visibility: &'a Visibility) {
284 if visibility.decl_ids.is_empty() && visibility.type_alias_ids.is_empty() {
285 return;
286 }
287 match self.inline.iter_mut().find(|layer| layer.is_none()) {
288 Some(layer) => *layer = Some(visibility),
289 None => self.spilled.push(visibility),
290 }
291 }
292
293 pub fn is_decl_id_visible(&self, decl_id: &DeclId) -> bool {
295 self.inline
296 .iter()
297 .map_while(|layer| *layer)
298 .chain(self.spilled.iter().copied())
299 .find_map(|visibility| visibility.decl_ids.get(decl_id))
300 .copied()
301 .unwrap_or(true) }
303
304 pub fn is_type_alias_id_visible(&self, type_alias_id: &TypeAliasId) -> bool {
306 self.inline
307 .iter()
308 .map_while(|layer| *layer)
309 .chain(self.spilled.iter().copied())
310 .find_map(|visibility| visibility.type_alias_ids.get(type_alias_id))
311 .copied()
312 .unwrap_or(true) }
314}
315
316#[derive(Debug, Clone)]
317pub struct ScopeFrame {
318 pub overlays: Vec<(Vec<u8>, OverlayFrame)>,
323
324 pub active_overlays: Vec<OverlayId>,
328
329 pub removed_overlays: Vec<Vec<u8>>,
331
332 pub predecls: DeclNameMap,
334
335 pub type_predecls: HashMap<Vec<u8>, Vec<Span>>,
338
339 pub hidden_vars: Vec<VarId>,
344}
345
346impl ScopeFrame {
347 pub fn new() -> Self {
348 Self {
349 overlays: vec![],
350 active_overlays: vec![],
351 removed_overlays: vec![],
352 predecls: DeclNameMap::new(),
353 type_predecls: HashMap::new(),
354 hidden_vars: vec![],
355 }
356 }
357
358 pub fn with_empty_overlay(name: Vec<u8>, origin: ModuleId, prefixed: bool) -> Self {
359 Self {
360 overlays: vec![(name, OverlayFrame::from_origin(origin, prefixed))],
361 active_overlays: vec![OverlayId::new(0)],
362 removed_overlays: vec![],
363 predecls: DeclNameMap::new(),
364 type_predecls: HashMap::new(),
365 hidden_vars: vec![],
366 }
367 }
368
369 pub fn get_var(&self, var_name: &[u8]) -> Option<&VarId> {
370 for overlay_id in self.active_overlays.iter().rev() {
371 if let Some(var_id) = self
372 .overlays
373 .get(overlay_id.get())
374 .expect("internal error: missing overlay")
375 .1
376 .vars
377 .get(var_name)
378 {
379 return Some(var_id);
380 }
381 }
382
383 None
384 }
385
386 pub fn active_overlay_ids(&self, removed_overlays: &mut Vec<Vec<u8>>) -> Vec<OverlayId> {
387 for name in &self.removed_overlays {
388 if !removed_overlays.contains(name) {
389 removed_overlays.push(name.clone());
390 }
391 }
392
393 self.active_overlays
394 .iter()
395 .filter(|id| {
396 !removed_overlays
397 .iter()
398 .any(|name| name == self.get_overlay_name(**id))
399 })
400 .copied()
401 .collect()
402 }
403
404 pub fn active_overlays<'a, 'b>(
405 &'b self,
406 removed_overlays: &'a mut Vec<Vec<u8>>,
407 ) -> impl DoubleEndedIterator<Item = &'b OverlayFrame> + 'a
408 where
409 'b: 'a,
410 {
411 for name in &self.removed_overlays {
414 if !removed_overlays.contains(name) {
415 removed_overlays.push(name.clone());
416 }
417 }
418 let removed_overlays: &'a Vec<Vec<u8>> = removed_overlays;
419
420 self.active_overlays
421 .iter()
422 .filter(move |id| {
423 !removed_overlays
424 .iter()
425 .any(|name| name == self.get_overlay_name(**id))
426 })
427 .map(|id| self.get_overlay(*id))
428 }
429
430 pub fn active_overlay_names(&self, removed_overlays: &mut Vec<Vec<u8>>) -> Vec<&[u8]> {
431 self.active_overlay_ids(removed_overlays)
432 .iter()
433 .map(|id| self.get_overlay_name(*id))
434 .collect()
435 }
436
437 pub fn get_overlay_name(&self, overlay_id: OverlayId) -> &[u8] {
438 &self
439 .overlays
440 .get(overlay_id.get())
441 .expect("internal error: missing overlay")
442 .0
443 }
444
445 pub fn get_overlay(&self, overlay_id: OverlayId) -> &OverlayFrame {
446 &self
447 .overlays
448 .get(overlay_id.get())
449 .expect("internal error: missing overlay")
450 .1
451 }
452
453 pub fn get_overlay_mut(&mut self, overlay_id: OverlayId) -> &mut OverlayFrame {
454 &mut self
455 .overlays
456 .get_mut(overlay_id.get())
457 .expect("internal error: missing overlay")
458 .1
459 }
460
461 pub fn find_overlay(&self, name: &[u8]) -> Option<OverlayId> {
462 self.overlays
463 .iter()
464 .position(|(n, _)| n == name)
465 .map(OverlayId::new)
466 }
467
468 pub fn find_active_overlay(&self, name: &[u8]) -> Option<OverlayId> {
469 self.overlays
470 .iter()
471 .position(|(n, _)| n == name)
472 .map(OverlayId::new)
473 .filter(|id| self.active_overlays.contains(id))
474 }
475}
476
477#[derive(Debug, Clone)]
478pub struct OverlayFrame {
479 pub vars: HashMap<Vec<u8>, VarId>,
480 pub predecls: DeclNameMap, pub decls: DeclNameMap,
482 pub modules: HashMap<Vec<u8>, ModuleId>,
483 pub type_aliases: HashMap<Vec<u8>, TypeAliasId>,
484 pub shadowed_vars: Vec<VarId>,
485 pub visibility: Visibility,
486 pub origin: ModuleId, pub prefixed: bool, }
489
490impl OverlayFrame {
491 pub fn from_origin(origin: ModuleId, prefixed: bool) -> Self {
492 Self {
493 vars: HashMap::new(),
494 predecls: DeclNameMap::new(),
495 decls: DeclNameMap::new(),
496 modules: HashMap::new(),
497 type_aliases: HashMap::new(),
498 shadowed_vars: Vec::new(),
499 visibility: Visibility::new(),
500 origin,
501 prefixed,
502 }
503 }
504
505 pub fn insert_decl(&mut self, name: Vec<u8>, decl_id: DeclId) -> Option<DeclId> {
506 self.decls.insert(name, decl_id)
507 }
508
509 pub fn insert_module(&mut self, name: Vec<u8>, module_id: ModuleId) -> Option<ModuleId> {
510 self.modules.insert(name, module_id)
511 }
512
513 pub fn insert_variable(&mut self, name: Vec<u8>, variable_id: VarId) -> Option<VarId> {
514 let res = self.vars.insert(name, variable_id);
515 if let Some(old_id) = res {
516 self.shadowed_vars.push(old_id);
517 }
518 res
519 }
520
521 pub fn get_decl(&self, name: &[u8]) -> Option<DeclId> {
522 self.decls.get(name).cloned()
523 }
524}
525
526impl Default for Visibility {
527 fn default() -> Self {
528 Self::new()
529 }
530}
531
532impl Default for ScopeFrame {
533 fn default() -> Self {
534 Self::new()
535 }
536}
537
538#[cfg(test)]
539mod visibility_stack_tests {
540 use super::*;
541
542 fn frame(hidden: &[usize], shown: &[usize]) -> Visibility {
544 let mut visibility = Visibility::new();
545 for id in hidden {
546 visibility.hide_decl_id(&DeclId::new(*id));
547 }
548 for id in shown {
549 visibility.use_decl_id(&DeclId::new(*id));
550 }
551 visibility
552 }
553
554 #[test]
555 fn innermost_frame_with_an_entry_wins_past_the_inline_frames() {
556 let frames: Vec<Visibility> = (0..7).map(|i| frame(&[i], &[i + 1])).collect();
558 let empty = Visibility::new();
559 let mut stack = VisibilityStack::default();
560 for visibility in &frames {
561 stack.push(&empty);
562 stack.push(visibility);
563 }
564 assert!(!stack.is_decl_id_visible(&DeclId::new(0)));
566 for id in 1..8 {
567 assert!(stack.is_decl_id_visible(&DeclId::new(id)), "decl {id}");
568 }
569 assert!(stack.is_decl_id_visible(&DeclId::new(100)));
571
572 let mut stack = VisibilityStack::default();
574 for visibility in frames.iter().rev() {
575 stack.push(visibility);
576 }
577 assert!(!stack.is_decl_id_visible(&DeclId::new(6)));
578 assert!(stack.is_decl_id_visible(&DeclId::new(7)));
579 assert!(!stack.is_decl_id_visible(&DeclId::new(1)));
580 }
581}