Chore: Expand IT, fix lambda and implement dict help methods (BuiltIn).

Author: dylan-sutton-chavez

compiler/src/modules/parser/control.rs

@@ -285,9 +285,14 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             self.eat(TokenType::Colon);
             self.compile_block();
 
-            // Only need a jump if there are more `except` arms after this one
-            // (i.e. we might fall through to another arm). Peek ahead.
-            if matches!(self.peek(), Some(TokenType::Except | TokenType::Else | TokenType::Finally)) {
+            // Always emit Jump after handler body — needed to skip remaining arms,
+            // the re-raise, and any else/finally. Exception: bare except with nothing
+            // after it (no else, no finally, no more except arms).
+            let more = matches!(
+                self.peek(),
+                Some(TokenType::Except | TokenType::Else | TokenType::Finally)
+            );
+            if !had_bare || more {
                 self.chunk.emit(OpCode::Jump, 0);
                 end_jumps.push(self.chunk.instructions.len() - 1);
             }

compiler/src/modules/parser/expr.rs

@@ -394,10 +394,15 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
 
     pub(super) fn parse_lambda(&mut self) {
         let mut params = Vec::new();
+        let mut defaults = 0u16;
         if !matches!(self.peek(), Some(TokenType::Colon)) {
             loop {
                 let p = self.advance();
                 params.push(self.lexeme(&p).to_string());
+                if self.eat_if(TokenType::Equal) {
+                    self.expr();
+                    defaults += 1;
+                }
                 if !self.eat_if(TokenType::Comma) {
                     break;
                 }
@@ -411,7 +416,7 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
             s.chunk.emit(OpCode::ReturnValue, 0);
         });
         let fi = self.chunk.functions.len() as u16;
-        self.chunk.functions.push((params, body, 0, u16::MAX));
+        self.chunk.functions.push((params, body, defaults, u16::MAX));
         self.chunk.emit(OpCode::MakeFunction, fi);
     }
 }

compiler/src/modules/parser/types.rs

@@ -239,8 +239,15 @@ fn unescape(s: &str) -> String {
 
 // Array containing the default data types for the language.
 pub const BUILTIN_TYPES: &[&str] = &[
-    "int", "float", "str", "bool", "list", 
-    "tuple", "dict", "set", "range", "type", "NoneType"
+    "int", "float", "str", "bool", "list",
+    "tuple", "dict", "set", "range", "type", "NoneType",
+    "Exception", "BaseException",
+    "ValueError", "TypeError", "NameError", "KeyError",
+    "IndexError", "AttributeError", "RuntimeError",
+    "ZeroDivisionError", "OverflowError", "MemoryError",
+    "RecursionError", "StopIteration", "NotImplementedError",
+    "OSError", "IOError", "ImportError", "ModuleNotFoundError",
+    "AssertionError", "ArithmeticError", "LookupError",
 ];
 
 // Map each opcode to its functional group for streamlined execution logic.

compiler/src/modules/vm/builtins.rs

@@ -337,11 +337,22 @@ impl<'a> VM<'a> {
         let (arg2, obj) = (self.pop()?, self.pop()?);
         let obj_ty = self.type_name(obj);
 
+        // Exception handler pushes the exception as a Str (e.g. "ZeroDivisionError").
+        // Allow isinstance("ZeroDivisionError", ZeroDivisionError) to return true
+        // by also comparing the string content against the type name.
+        let obj_as_str: Option<String> = if obj.is_heap() {
+            match self.heap.get(obj) {
+                HeapObj::Str(s) => Some(s.clone()),
+                _ => None,
+            }
+        } else { None };
+
         let check = |t: Val, heap: &HeapPool| -> Result<bool, VmErr> {
             match heap.get(t) {
                 HeapObj::Type(name) => Ok(
                     name == obj_ty
                     || (obj_ty == "bool" && name == "int")
+                    || obj_as_str.as_deref() == Some(name.as_str())
                 ),
                 _ => Err(VmErr::Type("isinstance() arg 2 must be a type or tuple of types")),
             }

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

@@ -13,8 +13,10 @@ impl<'a> VM<'a> {
 
         let method_id = match (self.type_name(obj), name.as_str()) {
             ("list", "append") => BuiltinMethodId::ListAppend,
+            ("dict", "keys")   => BuiltinMethodId::DictKeys,
+            ("dict", "values") => BuiltinMethodId::DictValues,
+            ("dict", "items")  => BuiltinMethodId::DictItems,
             (ty, attr) => {
-                // Out-of-line so the hot path stays small.
                 return Err(attr_not_found(ty, attr));
             }
         };

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

@@ -234,6 +234,47 @@ impl<'a> VM<'a> {
                 self.push(Val::none());
                 Ok(())
             }
+            DictKeys => {
+                if !positional.is_empty() {
+                    return Err(VmErr::Type("keys() takes no arguments"));
+                }
+                let keys: Vec<Val> = match self.heap.get(recv) {
+                    HeapObj::Dict(rc) => rc.borrow().keys().collect(),
+                    _ => return Err(VmErr::Type("keys: receiver is not a dict")),
+                };
+                let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(keys))))?;
+                self.push(val);
+                Ok(())
+            }
+            DictValues => {
+                if !positional.is_empty() {
+                    return Err(VmErr::Type("values() takes no arguments"));
+                }
+                let values: Vec<Val> = match self.heap.get(recv) {
+                    HeapObj::Dict(rc) => rc.borrow().entries.iter().map(|&(_, v)| v).collect(),
+                    _ => return Err(VmErr::Type("values: receiver is not a dict")),
+                };
+                let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(values))))?;
+                self.push(val);
+                Ok(())
+            }
+            DictItems => {
+                if !positional.is_empty() {
+                    return Err(VmErr::Type("items() takes no arguments"));
+                }
+                let pairs: Vec<(Val, Val)> = match self.heap.get(recv) {
+                    HeapObj::Dict(rc) => rc.borrow().entries.clone(),
+                    _ => return Err(VmErr::Type("items: receiver is not a dict")),
+                };
+                let mut items: Vec<Val> = Vec::with_capacity(pairs.len());
+                for (k, v) in pairs {
+                    let t = self.heap.alloc(HeapObj::Tuple(vec![k, v]))?;
+                    items.push(t);
+                }
+                let val = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(items))))?;
+                self.push(val);
+                Ok(())
+            }
         }
     }
 }

compiler/src/modules/vm/ops.rs

@@ -123,6 +123,9 @@ impl<'a> VM<'a> {
             HeapObj::Func(i, _) => format!("<function {}>", i),
             HeapObj::BoundMethod(_, id) => match id {
                 BuiltinMethodId::ListAppend => "<built-in method append>".into(),
+                BuiltinMethodId::DictKeys   => "<built-in method keys>".into(),
+                BuiltinMethodId::DictValues => "<built-in method values>".into(),
+                BuiltinMethodId::DictItems  => "<built-in method items>".into(),
             },
             HeapObj::Slice(s, e, st) => format!("slice({}, {}, {})",
                 self.display(*s), self.display(*e), self.display(*st)),

compiler/src/modules/vm/types.rs

@@ -466,6 +466,9 @@ pub enum HeapObj {
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum BuiltinMethodId {
     ListAppend,
+    DictKeys,
+    DictValues,
+    DictItems,
 }
 
 /*

compiler/tests/cases/vm.json

@@ -285,54 +285,40 @@
   {"src": "counter: int = 0\nfor _ in range(100):\n    counter += 1\n    counter += 2\nprint(counter)", "output": ["300"], "result": "None"},
   {"src": "counter: float = 0.0\nfor _ in range(50): counter += 1\nprint(counter)", "output": ["50.0"], "result": "None"},
   {"src": "total: int = 0\nfor i in range(5):\n    for j in range(5):\n        total += 1\nprint(total)", "output": ["25"], "result": "None"},
-
   {"src": "if (n := 5) > 3:\n    print(n)", "output": ["5"], "result": "None"},
   {"src": "data = [1, 2, 3]\nif (length := len(data)) > 0:\n    print(length)", "output": ["3"], "result": "None"},
   {"src": "x = 0\nwhile (x := x + 1) < 5:\n    print(x)", "output": ["1", "2", "3", "4"], "result": "None"},
-
   {"src": "name = 'world'\nage = 42\nprint(f'{name} is {age} years old')", "output": ["world is 42 years old"], "result": "None"},
   {"src": "print(f'{1 + 2 + 3}')", "output": ["6"], "result": "None"},
   {"src": "x = [1, 2, 3]\nprint(f'len={len(x)}')", "output": ["len=3"], "result": "None"},
-
   {"src": "a = [1,2,3,4,5]\nprint(a[1:4:2])", "output": ["[2, 4]"], "result": "None"},
   {"src": "a = [1,2,3,4,5]\nprint(a[-3:])", "output": ["[3, 4, 5]"], "result": "None"},
   {"src": "a = [1,2,3,4,5]\nprint(a[:-2])", "output": ["[1, 2, 3]"], "result": "None"},
   {"src": "s = 'abcdef'\nprint(s[::-1])", "output": ["fedcba"], "result": "None"},
   {"src": "t = (1,2,3,4,5)\nprint(t[1:-1])", "output": ["(2, 3, 4)"], "result": "None"},
-
   {"src": "a = 2**100\nb = 2**100\nprint(a == b)", "output": ["True"], "result": "None"},
   {"src": "a = 2**100\nb = 2**99\nprint(a > b)", "output": ["True"], "result": "None"},
   {"src": "print((2**100) // 7 * 7 + (2**100) % 7 == 2**100)", "output": ["True"], "result": "None"},
-
   {"src": "s = {1, 2, 3}\nprint(2 in s)", "output": ["True"], "result": "None"},
   {"src": "s = {1, 2, 3}\nprint(5 in s)", "output": ["False"], "result": "None"},
   {"src": "print(set([1,1,2,2,3]) == {1,2,3})", "output": ["True"], "result": "None"},
-
-  {"src": "try:\n    x = 1/0\nexcept:\n    x = -1\nprint(x)", "output": ["-1"], "result": "None"},
-  {"src": "try:\n    x = int('abc')\nexcept:\n    x = 0\nprint(x)", "output": ["0"], "result": "None"},
-
   {"src": "def f():\n    yield 1\n    yield 2\n    yield 3\nresult = list(f())\nprint(result)", "output": ["[1, 2, 3]"], "result": "None"},
   {"src": "def squares(n):\n    for i in range(n):\n        yield i*i\nprint(list(squares(5)))", "output": ["[0, 1, 4, 9, 16]"], "result": "None"},
-
   {"src": "def make_counter():\n    count = 0\n    def inc():\n        return count + 1\n    return inc()\nprint(make_counter())", "output": ["1"], "result": "None"},
-
   {"src": "x = -2**100\nprint(x)", "output": ["-1267650600228229401496703205376"], "result": "None"},
   {"src": "print(abs(-2**60 - 2**60))", "output": ["2305843009213693952"], "result": "None"},
-
   {"src": "for i in range(3):\n    for j in range(3):\n        print(i, j)", "output": ["0 0", "0 1", "0 2", "1 0", "1 1", "1 2", "2 0", "2 1", "2 2"], "result": "None"},
   {"src": "try:\n    x = 1/0\nexcept:\n    x = -1\nprint(x)", "output": ["-1"], "result": "None"},
   {"src": "try:\n    x = int('abc')\nexcept:\n    x = 0\nprint(x)", "output": ["0"], "result": "None"},
   {"src": "try:\n    x = 1\nexcept:\n    x = -1\nprint(x)", "output": ["1"], "result": "None"},
   {"src": "try:\n    a = [1,2,3]\n    b = a[10]\nexcept:\n    b = -1\nprint(b)", "output": ["-1"], "result": "None"},
   {"src": "result = 0\nfor i in range(5):\n    try:\n        result += 10 // (i - 2)\n    except:\n        result += 100\nprint(result)", "output": ["100"], "result": "None"},
-
   {"src": "calls = []\ndef side(name, val):\n    calls.append(name)\n    return val\nresult = side('a', False) and side('b', True)\nprint(calls)\nprint(result)", "output": ["['a']", "False"], "result": "None"},
   {"src": "calls = []\ndef side(name, val):\n    calls.append(name)\n    return val\nresult = side('a', True) or side('b', False)\nprint(calls)\nprint(result)", "output": ["['a']", "True"], "result": "None"},
   {"src": "x = 0 or 'fallback'\nprint(x)", "output": ["fallback"], "result": "None"},
   {"src": "x = 'first' and 'second'\nprint(x)", "output": ["second"], "result": "None"},
   {"src": "x = None or 0 or [] or 'default'\nprint(x)", "output": ["default"], "result": "None"},
   {"src": "x = 1 and 2 and 3\nprint(x)", "output": ["3"], "result": "None"},
-
   {"src": "print(1 < 2 < 3)", "output": ["True"], "result": "None"},
   {"src": "print(1 < 3 < 2)", "output": ["False"], "result": "None"},
   {"src": "print(3 < 2 < 1)", "output": ["False"], "result": "None"},
@@ -341,5 +327,27 @@
   {"src": "x = 5\nprint(0 < x < 10)", "output": ["True"], "result": "None"},
   {"src": "x = 15\nprint(0 < x < 10)", "output": ["False"], "result": "None"},
   {"src": "print(1 == 1 == 1)", "output": ["True"], "result": "None"},
-  {"src": "print(1 == 1 == 2)", "output": ["False"], "result": "None"}
+  {"src": "print(1 == 1 == 2)", "output": ["False"], "result": "None"},
+  {"src": "x = []\nx.append(1)\nx.append(2)\nprint(x)", "output": ["[1, 2]"], "result": "None"},
+  {"src": "print([y := x + 1 for x in range(3)])", "output": ["[1, 2, 3]"], "result": "None"},
+  {"src": "try:\n    x = 1/0\nexcept ValueError:\n    x = -1\nexcept:\n    x = -2\nprint(x)", "output": ["-2"], "result": "None"},
+  {"src": "try:\n    raise 'boom'\nexcept:\n    x = 'caught'\nprint(x)", "output": ["caught"], "result": "None"},
+  {"src": "def outer():\n    items = []\n    def inner(x):\n        items.append(x)\n    inner(1)\n    inner(2)\n    return items\nprint(outer())", "output": ["[1, 2]"], "result": "None"},
+  {"src": "def f(x, acc=[]):\n    acc.append(x)\n    return acc\nprint(f(1))\nprint(f(2))", "output": ["[1]", "[1, 2]"], "result": "None"},
+  {"src": "a, b, c = 1, 2, 3\nprint(a < b < c)", "output": ["True"], "result": "None"},
+  {"src": "a, b, c = 1, 3, 2\nprint(a < b < c)", "output": ["False"], "result": "None"},
+  {"src": "for i in range(3):\n    pass\nelse:\n    print('done')", "output": ["done"], "result": "None"},
+  {"src": "for i in range(3):\n    if i == 1:\n        break\nelse:\n    print('done')\nprint('end')", "output": ["end"], "result": "None"},
+  {"src": "x = 0\nwhile x < 3:\n    x += 1\nelse:\n    print('done')", "output": ["done"], "result": "None"},
+  {"src": "d = {}\nfor i in [3,1,2]:\n    d[i] = i\nprint(list(d.keys()))", "output": ["[3, 1, 2]"], "result": "None"},
+  {"src": "d = {'a': 1, 'b': 2}\nprint(list(d.values()))", "output": ["[1, 2]"], "result": "None"},
+  {"src": "d = {}\nfor i in [3,1,2]:\n    d[i] = i\nprint(list(d.keys()))", "output": ["[3, 1, 2]"], "result": "None"},
+  {"src": "print(2**100 > 2**99 > 2**98)", "output": ["True"], "result": "None"},
+  {"src": "print({x % 3 for x in range(9)})", "output": ["{0, 1, 2}"], "result": "None"},
+  {"src": "x = 0\nfor i in range(1000):\n    x = {'v': i}\nprint(x['v'])", "output": ["999"], "result": "None"},
+  {"src": "def fib(n):\n    if n < 2: return n\n    return fib(n-1) + fib(n-2)\nprint(fib(15))", "output": ["610"], "result": "None"},
+  {"src": "print('abcde'[3:0:-1])", "output": ["dcb"], "result": "None"},
+  {"src": "for a, *b in [[1,2,3],[4,5,6]]:\n    print(a, b)", "output": ["1 [2, 3]", "4 [5, 6]"], "result": "None"},
+  {"src": "try:\n    x = 1/0\nexcept ZeroDivisionError as e:\n    print('caught')", "output": ["caught"], "result": "None"},
+  {"src": "f = lambda x, y=10: x + y\nprint(f(5))\nprint(f(5, 1))", "output": ["15", "6"], "result": "None"}
 ]