Fix: Dictionary equality comparison in deep value equality.

Author: dylan-sutton-chavez

compiler/src/modules/vm/cache.rs

@@ -1,6 +1,6 @@
 // vm/cache.rs
 
-use super::types::{Val, eq_vals_deep};
+use super::types::{Val, eq_vals_with_heap};
 use crate::modules::parser::OpCode;
 use alloc::{vec, vec::Vec};
 use hashbrown::HashMap;
@@ -96,7 +96,7 @@ impl Templates {
             .find(|e| {
                 e.hits >= TPL_THRESH
                 && e.args.len() == args.len()
-                && e.args.iter().zip(args).all(|(a, b)| eq_vals_deep(*a, *b, heap))
+                && e.args.iter().zip(args).all(|(a, b)| eq_vals_with_heap(*a, *b, heap))
             })
             .map(|e| e.result)
     }
@@ -105,7 +105,7 @@ impl Templates {
         let v = self.map.entry(fi).or_default();
         if let Some(e) = v.iter_mut().find(|e| {
             e.args.len() == args.len()
-            && e.args.iter().zip(args).all(|(a, b)| eq_vals_deep(*a, *b, heap))
+            && e.args.iter().zip(args).all(|(a, b)| eq_vals_with_heap(*a, *b, heap))
         }) {
             e.hits += 1; e.result = result;
         } else if v.len() < 256 {

compiler/src/modules/vm/mod.rs

@@ -417,9 +417,12 @@ pub(crate) fn exec(&mut self, chunk: &SSAChunk, slots: &mut Vec<Option<Val>>) ->
 
                 // Comparison (cached)
 
-                OpCode::Eq => { let (a, b) = self.pop2()?; cached_binop!(self.heap, rip, &ins.opcode, a, b, cache); self.push(Val::bool(self.eq_vals(a, b))); }
+                OpCode::Eq => { let (a, b) = self.pop2()?; cached_binop!(self.heap, rip, &ins.opcode, a, b, cache); self.push(Val::bool(eq_vals_with_heap(a, b, &self.heap))); }
                 OpCode::Lt => { let (a, b) = self.pop2()?; cached_binop!(self.heap, rip, &ins.opcode, a, b, cache); let r = self.lt_vals(a, b)?; self.push(Val::bool(r)); }
-                OpCode::NotEq => { let (a,b) = self.pop2()?; self.push(Val::bool(!self.eq_vals(a,b))); }
+                OpCode::NotEq => { 
+                    let (a, b) = self.pop2()?; 
+                    self.push(Val::bool(!eq_vals_with_heap(a, b, &self.heap))); 
+                }
                 OpCode::Gt => { let (a,b) = self.pop2()?; let r=self.lt_vals(b,a)?; self.push(Val::bool(r)); }
                 OpCode::LtEq => { let (a,b) = self.pop2()?; let r=self.lt_vals(b,a)?; self.push(Val::bool(!r)); }
                 OpCode::GtEq => { let (a,b) = self.pop2()?; let r=self.lt_vals(a,b)?; self.push(Val::bool(!r)); }

compiler/src/modules/vm/ops.rs

@@ -107,10 +107,6 @@ impl<'a> VM<'a> {
         self.display(v)
     }
 
-    pub fn eq_vals(&self, a: Val, b: Val) -> bool {
-        super::types::eq_vals_deep(a, b, &self.heap)
-    }
-
     pub fn lt_vals(&self, a: Val, b: Val) -> Result<bool, VmErr> {
         if let (Some(ba), Some(bb)) = (self.to_bigint(a), self.to_bigint(b)) {
             return Ok(ba.cmp(&bb) == core::cmp::Ordering::Less);
@@ -131,18 +127,17 @@ impl<'a> VM<'a> {
     pub fn contains(&self, container: Val, item: Val) -> bool {
         if !container.is_heap() { return false; }
         match self.heap.get(container) {
-            HeapObj::List(v) => v.borrow().iter().any(|x| self.eq_vals(*x, item)),
-            HeapObj::Tuple(v) => v.iter().any(|x| self.eq_vals(*x, item)),
+            HeapObj::List(v) => v.borrow().iter().any(|x| eq_vals_with_heap(*x, item, &self.heap)),
+            HeapObj::Tuple(v) => v.iter().any(|x| eq_vals_with_heap(*x, item, &self.heap)),
             HeapObj::Dict(p) => p.borrow().contains_key(&item),
-            HeapObj::Set(s) => s.borrow().iter().any(|x| self.eq_vals(*x, item)),
+            HeapObj::Set(s) => s.borrow().iter().any(|x| eq_vals_with_heap(*x, item, &self.heap)),
             HeapObj::Str(s) => {
                 if item.is_heap() { if let HeapObj::Str(sub) = self.heap.get(item) { return s.contains(sub.as_str()); } }
                 false
             }
             _ => false,
         }
     }
-
     pub fn add_vals(&mut self, a: Val, b: Val) -> Result<Val, VmErr> {
         if let (Some(ba), Some(bb)) = (self.to_bigint(a), self.to_bigint(b)) {
             return self.bigint_to_val(ba.add(&bb));

compiler/src/modules/vm/types.rs

@@ -561,24 +561,26 @@ pub(super) fn eq_dict(a: &DictMap, b: &DictMap, eq: impl Fn(Val,Val)->bool) -> b
     a.len() == b.len() && a.iter().all(|(k,v)| b.get(&k).map_or(false, |&v2| eq(v,v2)))
 }
 
-pub fn eq_vals_deep(a: Val, b: Val, heap: &HeapPool) -> bool {
+pub fn eq_vals_with_heap(a: Val, b: Val, heap: &HeapPool) -> bool {
     if let (Some(ba), Some(bb)) = (bigint_of(a, heap), bigint_of(b, heap)) {
         return ba.cmp(&bb) == core::cmp::Ordering::Equal;
     }
+
     if !a.is_heap() || !b.is_heap() {
         if a.is_int() && b.is_int() { return a.as_int() == b.as_int(); }
         if a.is_float() && b.is_float() { return a.as_float() == b.as_float(); }
         if a.is_int() && b.is_float() { return (a.as_int() as f64) == b.as_float(); }
         if a.is_float() && b.is_int() { return a.as_float() == (b.as_int() as f64); }
         return a.0 == b.0;
     }
+
     match (heap.get(a), heap.get(b)) {
         (HeapObj::BigInt(x), HeapObj::BigInt(y)) => x.cmp(y) == core::cmp::Ordering::Equal,
-        (HeapObj::Str(x),   HeapObj::Str(y))   => x == y,
-        (HeapObj::Tuple(x), HeapObj::Tuple(y)) => eq_seq(x, y, |a,b| eq_vals_deep(a,b,heap)),
-        (HeapObj::List(x),  HeapObj::List(y))  => eq_seq(&x.borrow(), &y.borrow(), |a,b| eq_vals_deep(a,b,heap)),
-        (HeapObj::Set(x),   HeapObj::Set(y))   => eq_set(&x.borrow(), &y.borrow(), |a,b| eq_vals_deep(a,b,heap)),
-        (HeapObj::Dict(x),  HeapObj::Dict(y))  => eq_dict(&x.borrow(), &y.borrow(), |a,b| eq_vals_deep(a,b,heap)),
+        (HeapObj::Str(x), HeapObj::Str(y)) => x == y,
+        (HeapObj::Tuple(x), HeapObj::Tuple(y)) => eq_seq(x, y, |a,b| eq_vals_with_heap(a, b, heap)),
+        (HeapObj::List(x), HeapObj::List(y)) => eq_seq(&x.borrow(), &y.borrow(), |a,b| eq_vals_with_heap(a, b, heap)),
+        (HeapObj::Set(x), HeapObj::Set(y)) => eq_set(&x.borrow(), &y.borrow(), |a,b| eq_vals_with_heap(a, b, heap)),
+        (HeapObj::Dict(x), HeapObj::Dict(y)) => eq_dict(&x.borrow(), &y.borrow(), |a,b| eq_vals_with_heap(a, b, heap)),
         _ => false,
     }
 }