use crate::{DeclId, ModuleId, OverlayId, Span, TypeAliasId, VarId};
use rustc_hash::FxBuildHasher;
use std::{
collections::HashMap,
ops::Deref,
sync::atomic::{AtomicUsize, Ordering},
};
static LONGEST_DECL_NAME: AtomicUsize = AtomicUsize::new(0);
pub fn longest_decl_name() -> usize {
LONGEST_DECL_NAME.load(Ordering::Relaxed)
}
#[derive(Debug, Clone, Default)]
pub struct DeclNameMap {
map: HashMap<Vec<u8>, DeclId, FxBuildHasher>,
longest_name: usize,
}
impl DeclNameMap {
pub fn new() -> Self {
Self::default()
}
pub fn get(&self, name: &[u8]) -> Option<&DeclId> {
if name.len() > self.longest_name {
return None;
}
self.map.get(name)
}
pub fn insert(&mut self, name: Vec<u8>, decl_id: DeclId) -> Option<DeclId> {
self.longest_name = self.longest_name.max(name.len());
LONGEST_DECL_NAME.fetch_max(name.len(), Ordering::Relaxed);
self.map.insert(name, decl_id)
}
pub fn remove(&mut self, name: &[u8]) -> Option<DeclId> {
self.map.remove(name)
}
pub fn remove_entry(&mut self, name: &[u8]) -> Option<(Vec<u8>, DeclId)> {
self.map.remove_entry(name)
}
}
impl Deref for DeclNameMap {
type Target = HashMap<Vec<u8>, DeclId, FxBuildHasher>;
fn deref(&self) -> &Self::Target {
&self.map
}
}
impl<'a> IntoIterator for &'a DeclNameMap {
type Item = (&'a Vec<u8>, &'a DeclId);
type IntoIter = std::collections::hash_map::Iter<'a, Vec<u8>, DeclId>;
fn into_iter(self) -> Self::IntoIter {
self.map.iter()
}
}
impl IntoIterator for DeclNameMap {
type Item = (Vec<u8>, DeclId);
type IntoIter = std::collections::hash_map::IntoIter<Vec<u8>, DeclId>;
fn into_iter(self) -> Self::IntoIter {
self.map.into_iter()
}
}
impl Extend<(Vec<u8>, DeclId)> for DeclNameMap {
fn extend<I: IntoIterator<Item = (Vec<u8>, DeclId)>>(&mut self, iter: I) {
for (name, decl_id) in iter {
self.insert(name, decl_id);
}
}
}
impl FromIterator<(Vec<u8>, DeclId)> for DeclNameMap {
fn from_iter<I: IntoIterator<Item = (Vec<u8>, DeclId)>>(iter: I) -> Self {
let mut map = Self::default();
map.extend(iter);
map
}
}
pub static DEFAULT_OVERLAY_NAME: &str = "zero";
#[derive(Debug, Clone)]
pub struct Visibility {
decl_ids: HashMap<DeclId, bool, FxBuildHasher>,
type_alias_ids: HashMap<TypeAliasId, bool, FxBuildHasher>,
}
#[derive(Debug, Clone, Default)]
pub struct BoundNames {
pub decls: Vec<(Vec<u8>, DeclId)>,
pub modules: Vec<(Vec<u8>, ModuleId)>,
pub vars: Vec<(Vec<u8>, VarId)>,
pub type_aliases: Vec<(Vec<u8>, TypeAliasId)>,
}
#[derive(Debug, Clone, Default)]
pub struct ScopeBindings {
pub decls: HashMap<Vec<u8>, DeclId>,
pub modules: HashMap<Vec<u8>, ModuleId>,
pub visibility: Visibility,
}
impl ScopeBindings {
pub fn is_empty(&self) -> bool {
self.decls.is_empty() && self.modules.is_empty() && self.visibility.decl_ids.is_empty()
}
pub fn extend_from_overlay(&mut self, overlay: &OverlayFrame) {
self.decls
.extend(overlay.decls.iter().map(|(k, v)| (k.clone(), *v)));
self.modules
.extend(overlay.modules.iter().map(|(k, v)| (k.clone(), *v)));
self.visibility.merge_with(overlay.visibility.clone());
}
pub fn extend_from_bindings(&mut self, other: &ScopeBindings) {
self.decls
.extend(other.decls.iter().map(|(k, v)| (k.clone(), *v)));
self.modules
.extend(other.modules.iter().map(|(k, v)| (k.clone(), *v)));
self.visibility.merge_with(other.visibility.clone());
}
}
impl Visibility {
pub fn new() -> Self {
Visibility {
decl_ids: HashMap::default(),
type_alias_ids: HashMap::default(),
}
}
pub fn is_decl_id_visible(&self, decl_id: &DeclId) -> bool {
*self.decl_ids.get(decl_id).unwrap_or(&true) }
pub fn hide_decl_id(&mut self, decl_id: &DeclId) {
self.decl_ids.insert(*decl_id, false);
}
pub fn use_decl_id(&mut self, decl_id: &DeclId) {
self.decl_ids.insert(*decl_id, true);
}
pub fn is_type_alias_id_visible(&self, type_alias_id: &TypeAliasId) -> bool {
*self.type_alias_ids.get(type_alias_id).unwrap_or(&true) }
pub fn hide_type_alias_id(&mut self, type_alias_id: &TypeAliasId) {
self.type_alias_ids.insert(*type_alias_id, false);
}
pub fn use_type_alias_id(&mut self, type_alias_id: &TypeAliasId) {
self.type_alias_ids.insert(*type_alias_id, true);
}
pub fn merge_with(&mut self, other: Visibility) {
self.decl_ids.extend(other.decl_ids);
self.type_alias_ids.extend(other.type_alias_ids);
}
pub fn append(&mut self, other: &Visibility) {
for (decl_id, visible) in other.decl_ids.iter() {
if !self.decl_ids.contains_key(decl_id) {
self.decl_ids.insert(*decl_id, *visible);
}
}
for (type_alias_id, visible) in other.type_alias_ids.iter() {
self.type_alias_ids
.entry(*type_alias_id)
.or_insert(*visible);
}
}
pub fn hides_more_than(&self, before: &Visibility) -> bool {
self.decl_ids
.iter()
.any(|(id, visible)| !visible && before.decl_ids.get(id) != Some(&false))
|| self
.type_alias_ids
.iter()
.any(|(id, visible)| !visible && before.type_alias_ids.get(id) != Some(&false))
}
}
#[derive(Debug, Default)]
pub struct VisibilityStack<'a> {
inline: [Option<&'a Visibility>; 4],
spilled: Vec<&'a Visibility>,
}
impl<'a> VisibilityStack<'a> {
pub fn push(&mut self, visibility: &'a Visibility) {
if visibility.decl_ids.is_empty() && visibility.type_alias_ids.is_empty() {
return;
}
match self.inline.iter_mut().find(|layer| layer.is_none()) {
Some(layer) => *layer = Some(visibility),
None => self.spilled.push(visibility),
}
}
pub fn is_decl_id_visible(&self, decl_id: &DeclId) -> bool {
self.inline
.iter()
.map_while(|layer| *layer)
.chain(self.spilled.iter().copied())
.find_map(|visibility| visibility.decl_ids.get(decl_id))
.copied()
.unwrap_or(true) }
pub fn is_type_alias_id_visible(&self, type_alias_id: &TypeAliasId) -> bool {
self.inline
.iter()
.map_while(|layer| *layer)
.chain(self.spilled.iter().copied())
.find_map(|visibility| visibility.type_alias_ids.get(type_alias_id))
.copied()
.unwrap_or(true) }
}
#[derive(Debug, Clone)]
pub struct ScopeFrame {
pub overlays: Vec<(Vec<u8>, OverlayFrame)>,
pub active_overlays: Vec<OverlayId>,
pub removed_overlays: Vec<Vec<u8>>,
pub predecls: DeclNameMap,
pub type_predecls: HashMap<Vec<u8>, Vec<Span>>,
pub hidden_vars: Vec<VarId>,
}
impl ScopeFrame {
pub fn new() -> Self {
Self {
overlays: vec![],
active_overlays: vec![],
removed_overlays: vec![],
predecls: DeclNameMap::new(),
type_predecls: HashMap::new(),
hidden_vars: vec![],
}
}
pub fn with_empty_overlay(name: Vec<u8>, origin: ModuleId, prefixed: bool) -> Self {
Self {
overlays: vec![(name, OverlayFrame::from_origin(origin, prefixed))],
active_overlays: vec![OverlayId::new(0)],
removed_overlays: vec![],
predecls: DeclNameMap::new(),
type_predecls: HashMap::new(),
hidden_vars: vec![],
}
}
pub fn get_var(&self, var_name: &[u8]) -> Option<&VarId> {
for overlay_id in self.active_overlays.iter().rev() {
if let Some(var_id) = self
.overlays
.get(overlay_id.get())
.expect("internal error: missing overlay")
.1
.vars
.get(var_name)
{
return Some(var_id);
}
}
None
}
pub fn active_overlay_ids(&self, removed_overlays: &mut Vec<Vec<u8>>) -> Vec<OverlayId> {
for name in &self.removed_overlays {
if !removed_overlays.contains(name) {
removed_overlays.push(name.clone());
}
}
self.active_overlays
.iter()
.filter(|id| {
!removed_overlays
.iter()
.any(|name| name == self.get_overlay_name(**id))
})
.copied()
.collect()
}
pub fn active_overlays<'a, 'b>(
&'b self,
removed_overlays: &'a mut Vec<Vec<u8>>,
) -> impl DoubleEndedIterator<Item = &'b OverlayFrame> + 'a
where
'b: 'a,
{
for name in &self.removed_overlays {
if !removed_overlays.contains(name) {
removed_overlays.push(name.clone());
}
}
let removed_overlays: &'a Vec<Vec<u8>> = removed_overlays;
self.active_overlays
.iter()
.filter(move |id| {
!removed_overlays
.iter()
.any(|name| name == self.get_overlay_name(**id))
})
.map(|id| self.get_overlay(*id))
}
pub fn active_overlay_names(&self, removed_overlays: &mut Vec<Vec<u8>>) -> Vec<&[u8]> {
self.active_overlay_ids(removed_overlays)
.iter()
.map(|id| self.get_overlay_name(*id))
.collect()
}
pub fn get_overlay_name(&self, overlay_id: OverlayId) -> &[u8] {
&self
.overlays
.get(overlay_id.get())
.expect("internal error: missing overlay")
.0
}
pub fn get_overlay(&self, overlay_id: OverlayId) -> &OverlayFrame {
&self
.overlays
.get(overlay_id.get())
.expect("internal error: missing overlay")
.1
}
pub fn get_overlay_mut(&mut self, overlay_id: OverlayId) -> &mut OverlayFrame {
&mut self
.overlays
.get_mut(overlay_id.get())
.expect("internal error: missing overlay")
.1
}
pub fn find_overlay(&self, name: &[u8]) -> Option<OverlayId> {
self.overlays
.iter()
.position(|(n, _)| n == name)
.map(OverlayId::new)
}
pub fn find_active_overlay(&self, name: &[u8]) -> Option<OverlayId> {
self.overlays
.iter()
.position(|(n, _)| n == name)
.map(OverlayId::new)
.filter(|id| self.active_overlays.contains(id))
}
}
#[derive(Debug, Clone)]
pub struct OverlayFrame {
pub vars: HashMap<Vec<u8>, VarId>,
pub predecls: DeclNameMap, pub decls: DeclNameMap,
pub modules: HashMap<Vec<u8>, ModuleId>,
pub type_aliases: HashMap<Vec<u8>, TypeAliasId>,
pub shadowed_vars: Vec<VarId>,
pub visibility: Visibility,
pub origin: ModuleId, pub prefixed: bool, }
impl OverlayFrame {
pub fn from_origin(origin: ModuleId, prefixed: bool) -> Self {
Self {
vars: HashMap::new(),
predecls: DeclNameMap::new(),
decls: DeclNameMap::new(),
modules: HashMap::new(),
type_aliases: HashMap::new(),
shadowed_vars: Vec::new(),
visibility: Visibility::new(),
origin,
prefixed,
}
}
pub fn insert_decl(&mut self, name: Vec<u8>, decl_id: DeclId) -> Option<DeclId> {
self.decls.insert(name, decl_id)
}
pub fn insert_module(&mut self, name: Vec<u8>, module_id: ModuleId) -> Option<ModuleId> {
self.modules.insert(name, module_id)
}
pub fn insert_variable(&mut self, name: Vec<u8>, variable_id: VarId) -> Option<VarId> {
let res = self.vars.insert(name, variable_id);
if let Some(old_id) = res {
self.shadowed_vars.push(old_id);
}
res
}
pub fn get_decl(&self, name: &[u8]) -> Option<DeclId> {
self.decls.get(name).cloned()
}
}
impl Default for Visibility {
fn default() -> Self {
Self::new()
}
}
impl Default for ScopeFrame {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod visibility_stack_tests {
use super::*;
fn frame(hidden: &[usize], shown: &[usize]) -> Visibility {
let mut visibility = Visibility::new();
for id in hidden {
visibility.hide_decl_id(&DeclId::new(*id));
}
for id in shown {
visibility.use_decl_id(&DeclId::new(*id));
}
visibility
}
#[test]
fn innermost_frame_with_an_entry_wins_past_the_inline_frames() {
let frames: Vec<Visibility> = (0..7).map(|i| frame(&[i], &[i + 1])).collect();
let empty = Visibility::new();
let mut stack = VisibilityStack::default();
for visibility in &frames {
stack.push(&empty);
stack.push(visibility);
}
assert!(!stack.is_decl_id_visible(&DeclId::new(0)));
for id in 1..8 {
assert!(stack.is_decl_id_visible(&DeclId::new(id)), "decl {id}");
}
assert!(stack.is_decl_id_visible(&DeclId::new(100)));
let mut stack = VisibilityStack::default();
for visibility in frames.iter().rev() {
stack.push(visibility);
}
assert!(!stack.is_decl_id_visible(&DeclId::new(6)));
assert!(stack.is_decl_id_visible(&DeclId::new(7)));
assert!(!stack.is_decl_id_visible(&DeclId::new(1)));
}
}