refactor: reduce coupling

evaluator/nixjit_eval/src/value/attrset.rs

@@ -0,0 +1,148 @@
+use core::ops::Deref;
+use std::rc::Rc;
+use std::fmt::Debug;
+
+use derive_more::Constructor;
+use hashbrown::{HashMap, HashSet};
+use itertools::Itertools;
+
+use nixjit_error::{Error, Result};
+use nixjit_value as p;
+use nixjit_value::Symbol;
+
+use super::Value;
+use crate::EvalContext;
+
+#[repr(transparent)]
+#[derive(Constructor, PartialEq)]
+pub struct AttrSet<Ctx: EvalContext> {
+    data: HashMap<String, Value<Ctx>>,
+}
+
+impl<Ctx: EvalContext> Debug for AttrSet<Ctx> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use Value::*;
+        write!(f, "{{ ")?;
+        for (k, v) in self.data.iter() {
+            match v {
+                List(_) => write!(f, "{k:?} = [ ... ]; ")?,
+                AttrSet(_) => write!(f, "{k:?} = {{ ... }}; ")?,
+                v => write!(f, "{k:?} = {v:?}; ")?,
+            }
+        }
+        write!(f, "}}")
+    }
+}
+
+impl<Ctx: EvalContext> Clone for AttrSet<Ctx> {
+    fn clone(&self) -> Self {
+        AttrSet {
+            data: self.data.clone(),
+        }
+    }
+}
+
+impl<Ctx: EvalContext> From<HashMap<String, Value<Ctx>>> for AttrSet<Ctx> {
+    fn from(data: HashMap<String, Value<Ctx>>) -> Self {
+        Self { data }
+    }
+}
+
+impl<Ctx: EvalContext> Deref for AttrSet<Ctx> {
+    type Target = HashMap<String, Value<Ctx>>;
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<Ctx: EvalContext> AttrSet<Ctx> {
+    pub fn with_capacity(cap: usize) -> Self {
+        AttrSet {
+            data: HashMap::with_capacity(cap),
+        }
+    }
+
+    pub fn push_attr_force(&mut self, sym: String, val: Value<Ctx>) {
+        self.data.insert(sym, val);
+    }
+
+    pub fn push_attr(&mut self, sym: String, val: Value<Ctx>) {
+        if self.data.get(&sym).is_some() {
+            todo!()
+        }
+        self.data.insert(sym, val);
+    }
+
+    pub fn select(
+        &self,
+        mut path: impl DoubleEndedIterator<Item = Result<String>>,
+    ) -> Result<Value<Ctx>> {
+        let mut data = &self.data;
+        let last = path.nth_back(0).unwrap();
+        for item in path {
+            let item = item?;
+            let Some(Value::AttrSet(attrs)) = data.get(&item) else {
+                return Err(Error::EvalError(format!(
+                    "attribute '{}' not found",
+                    Symbol::from(item)
+                )));
+            };
+            data = attrs.as_inner();
+        }
+        let last = last?;
+        data.get(&last).cloned().ok_or_else(|| {
+            Error::EvalError(format!("attribute '{}' not found", Symbol::from(last)))
+        })
+    }
+
+    pub fn has_attr(
+        &self,
+        mut path: impl DoubleEndedIterator<Item = Result<String>>,
+    ) -> Result<bool> {
+        let mut data = &self.data;
+        let last = path.nth_back(0).unwrap();
+        for item in path {
+            let Some(Value::AttrSet(attrs)) = data.get(&item?) else {
+                return Ok(false);
+            };
+            data = attrs.as_inner();
+        }
+        Ok(data.get(&last?).is_some())
+    }
+
+    pub fn update(&mut self, other: &Self) {
+        for (k, v) in other.data.iter() {
+            self.push_attr_force(k.clone(), v.clone())
+        }
+    }
+
+    pub fn as_inner(&self) -> &HashMap<String, Value<Ctx>> {
+        &self.data
+    }
+
+    pub fn into_inner(self: Rc<Self>) -> Rc<HashMap<String, Value<Ctx>>> {
+        unsafe { core::mem::transmute(self) }
+    }
+
+    pub fn from_inner(data: HashMap<String, Value<Ctx>>) -> Self {
+        Self { data }
+    }
+
+    pub fn eq_impl(&self, other: &Self) -> bool {
+        self.data.iter().len() == other.data.iter().len()
+            && std::iter::zip(
+                self.data.iter().sorted_by(|(a, _), (b, _)| a.cmp(b)),
+                other.data.iter().sorted_by(|(a, _), (b, _)| a.cmp(b)),
+            )
+            .all(|((k1, v1), (k2, v2))| k1 == k2 && v1.eq_impl(v2))
+    }
+
+    pub fn to_public(&self, ctx: &Ctx, seen: &mut HashSet<Value<Ctx>>) -> p::Value {
+        p::Value::AttrSet(p::AttrSet::new(
+            self.data
+                .iter()
+                .map(|(sym, value)| (sym.as_str().into(), value.to_public(ctx, seen)))
+                .collect(),
+        ))
+    }
+}