Feat: Add missing dict OpCodes.

Author: dylan-sutton-chavez

compiler/src/modules/vm/handlers/attr.rs

@@ -33,6 +33,9 @@ impl<'a> VM<'a> {
             ("list", "remove")      => BuiltinMethodId::ListRemove,
             ("list", "index")       => BuiltinMethodId::ListIndex,
             ("list", "count")       => BuiltinMethodId::ListCount,
+            ("dict", "get")         => BuiltinMethodId::DictGet,
+            ("dict", "update")      => BuiltinMethodId::DictUpdate,
+            ("dict", "pop")         => BuiltinMethodId::DictPop,
             (ty, attr) => {
                 return Err(attr_not_found(ty, attr));
             }

compiler/src/modules/vm/handlers/function.rs

@@ -512,7 +512,7 @@ impl<'a> VM<'a> {
                 self.push(Val::int(idx));
                 Ok(())
             }
-            ListCount => {
+ListCount => {
                 if positional.len() != 1 {
                     return Err(VmErr::Type("count() takes exactly one argument"));
                 }
@@ -526,6 +526,62 @@ impl<'a> VM<'a> {
                 self.push(Val::int(n));
                 Ok(())
             }
+            DictGet => {
+                if positional.is_empty() || positional.len() > 2 {
+                    return Err(VmErr::Type("get() takes 1 or 2 arguments"));
+                }
+                let key      = positional[0];
+                let default  = if positional.len() == 2 { positional[1] } else { Val::none() };
+                let result = match self.heap.get(recv) {
+                    HeapObj::Dict(rc) => rc.borrow().get(&key).copied().unwrap_or(default),
+                    _ => return Err(VmErr::Type("get: receiver is not a dict")),
+                };
+                self.push(result);
+                Ok(())
+            }
+            DictUpdate => {
+                if positional.len() != 1 {
+                    return Err(VmErr::Type("update() takes exactly one argument"));
+                }
+                let pairs = match self.heap.get(positional[0]) {
+                    HeapObj::Dict(rc) => rc.borrow().entries.clone(),
+                    _ => return Err(VmErr::Type("update() argument must be a dict")),
+                };
+                match self.heap.get_mut(recv) {
+                    HeapObj::Dict(rc) => {
+                        let mut b = rc.borrow_mut();
+                        for (k, v) in pairs { b.insert(k, v); }
+                    }
+                    _ => return Err(VmErr::Type("update: receiver is not a dict")),
+                }
+                self.mark_impure();
+                self.push(Val::none());
+                Ok(())
+            }
+            DictPop => {
+                if positional.is_empty() || positional.len() > 2 {
+                    return Err(VmErr::Type("pop() takes 1 or 2 arguments"));
+                }
+                let key     = positional[0];
+                let default = if positional.len() == 2 { Some(positional[1]) } else { None };
+                let result = match self.heap.get_mut(recv) {
+                    HeapObj::Dict(rc) => {
+                        let mut b = rc.borrow_mut();
+                        if let Some(val) = b.remove(&key) {
+                            val
+                        } else {
+                            match default {
+                                Some(d) => d,
+                                None    => return Err(VmErr::Value("key not found")),
+                            }
+                        }
+                    }
+                    _ => return Err(VmErr::Type("pop: receiver is not a dict")),
+                };
+                self.mark_impure();
+                self.push(result);
+                Ok(())
+            }
         }
     }
 

compiler/src/modules/vm/ops.rs

@@ -143,6 +143,9 @@ impl<'a> VM<'a> {
                 BuiltinMethodId::ListRemove     => "<built-in method remove>".into(),
                 BuiltinMethodId::ListIndex      => "<built-in method index>".into(),
                 BuiltinMethodId::ListCount      => "<built-in method count>".into(),
+                BuiltinMethodId::DictGet        => "<built-in method get>".into(),
+                BuiltinMethodId::DictUpdate     => "<built-in method update>".into(),
+                BuiltinMethodId::DictPop        => "<built-in method pop>".into(),
             },
             HeapObj::Slice(s, e, st) => format!("slice({}, {}, {})",
                 self.display(*s), self.display(*e), self.display(*st)),

compiler/src/modules/vm/types.rs

@@ -486,6 +486,9 @@ pub enum BuiltinMethodId {
     ListRemove,
     ListIndex,
     ListCount,
+    DictGet,
+    DictUpdate,
+    DictPop,
 }
 
 /*
@@ -546,6 +549,17 @@ impl Default for DictMap {
 
 impl DictMap {
     pub fn new() -> Self { Self { entries: Vec::new(), index: HashMap::default() } }
+
+    pub fn remove(&mut self, key: &Val) -> Option<Val> {
+        let idx = *self.index.get(key)?;
+        let val = self.entries[idx].1;
+        self.entries.remove(idx);
+        self.index.clear();
+        for (i, (k, _)) in self.entries.iter().enumerate() {
+            self.index.insert(*k, i);
+        }
+        Some(val)
+    }
 }
 
 /*

compiler/tests/cases/vm.json

@@ -366,5 +366,9 @@
   {"src": "x = [1,2,3]\nx.insert(1, 99)\nprint(x)", "output": ["[1, 99, 2, 3]"], "result": "None"},
   {"src": "x = [1,2,2,3]\nx.remove(2)\nprint(x)", "output": ["[1, 2, 3]"], "result": "None"},
   {"src": "print([1,2,3].index(2))", "output": ["1"], "result": "None"},
-  {"src": "print([1,2,2,3].count(2))", "output": ["2"], "result": "None"}
+  {"src": "print([1,2,2,3].count(2))", "output": ["2"], "result": "None"},
+  {"src": "d = {'a':1}\nprint(d.get('a'))", "output": ["1"], "result": "None"},
+  {"src": "d = {'a':1}\nprint(d.get('z', 0))", "output": ["0"], "result": "None"},
+  {"src": "d = {'a':1,'b':2}\nd.update({'b':9,'c':3})\nprint(d)", "output": ["{'a': 1, 'b': 9, 'c': 3}"], "result": "None"},
+  {"src": "d = {'a':1}\nd.pop('a')\nprint(d)", "output": ["{}"], "result": "None"}
 ]