109 lines
3.0 KiB
Rust
109 lines
3.0 KiB
Rust
use std::rc::Rc;
|
|
|
|
use hashbrown::{HashMap, HashSet};
|
|
|
|
use derive_more::Constructor;
|
|
use itertools::Itertools;
|
|
|
|
use crate::error::Result;
|
|
use crate::vm::{LetEnv, VM};
|
|
|
|
use super::super::public as p;
|
|
use super::Value;
|
|
|
|
#[repr(C)]
|
|
#[derive(Debug, Default, Constructor, Clone, PartialEq)]
|
|
pub struct AttrSet<'jit: 'vm, 'vm> {
|
|
data: HashMap<usize, Value<'jit, 'vm>>,
|
|
}
|
|
|
|
impl<'jit, 'vm> From<HashMap<usize, Value<'jit, 'vm>>> for AttrSet<'jit, 'vm> {
|
|
fn from(data: HashMap<usize, Value<'jit, 'vm>>) -> Self {
|
|
Self { data }
|
|
}
|
|
}
|
|
|
|
impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
|
|
pub fn with_capacity(cap: usize) -> Self {
|
|
AttrSet {
|
|
data: HashMap::with_capacity(cap),
|
|
}
|
|
}
|
|
|
|
pub fn push_attr_force(&mut self, sym: usize, val: Value<'jit, 'vm>) {
|
|
self.data.insert(sym, val);
|
|
}
|
|
|
|
pub fn push_attr(&mut self, sym: usize, val: Value<'jit, 'vm>) {
|
|
if self.data.get(&sym).is_some() {
|
|
todo!()
|
|
}
|
|
self.data.insert(sym, val);
|
|
}
|
|
|
|
pub fn select(&self, sym: usize) -> Option<Value<'jit, 'vm>> {
|
|
self.data.get(&sym).cloned().map(|val| match val {
|
|
Value::Builtins(x) => Value::AttrSet(x.upgrade().unwrap()),
|
|
val => val
|
|
})
|
|
}
|
|
|
|
pub fn has_attr(&self, sym: usize) -> bool {
|
|
self.data.get(&sym).is_some()
|
|
}
|
|
|
|
pub fn capture(&mut self, env: &Rc<LetEnv<'jit, 'vm>>) {
|
|
self.data.iter().for_each(|(_, v)| match v.clone() {
|
|
Value::Thunk(ref thunk) => {
|
|
thunk.capture(env.clone());
|
|
}
|
|
_ => (),
|
|
})
|
|
}
|
|
|
|
pub fn update(&mut self, other: &AttrSet<'jit, 'vm>) {
|
|
for (k, v) in other.data.iter() {
|
|
self.push_attr_force(k.clone(), v.clone())
|
|
}
|
|
}
|
|
|
|
pub fn as_inner(&self) -> &HashMap<usize, Value<'jit, 'vm>> {
|
|
&self.data
|
|
}
|
|
|
|
pub fn from_inner(data: HashMap<usize, Value<'jit, 'vm>>) -> Self {
|
|
Self { data }
|
|
}
|
|
|
|
pub fn force_deep(&mut self, vm: &'vm VM<'jit>) -> Result<()> {
|
|
let mut map: Vec<_> = self
|
|
.data
|
|
.iter()
|
|
.map(|(k, v)| (k.clone(), v.clone()))
|
|
.collect();
|
|
for (_, v) in map.iter_mut() {
|
|
v.force_deep(vm)?;
|
|
}
|
|
self.data = map.into_iter().collect();
|
|
Ok(())
|
|
}
|
|
|
|
pub fn eq_impl(&self, other: &AttrSet<'jit, 'vm>, vm: &'vm VM<'jit>) -> bool {
|
|
self.data.iter().len() == other.data.iter().len()
|
|
&& std::iter::zip(
|
|
self.data.iter().sorted_by_key(|(k, _)| **k),
|
|
self.data.iter().sorted_by_key(|(k, _)| **k),
|
|
)
|
|
.all(|((_, v1), (_, v2))| v1.eq_impl(v2, vm))
|
|
}
|
|
|
|
pub fn to_public(&self, vm: &'vm VM, seen: &mut HashSet<Value<'jit, 'vm>>) -> p::Value {
|
|
p::Value::AttrSet(p::AttrSet::new(
|
|
self.data
|
|
.iter()
|
|
.map(|(&sym, value)| (vm.get_sym(sym), value.to_public(vm, seen)))
|
|
.collect(),
|
|
))
|
|
}
|
|
}
|