Feat: Add missing Builtin's methods.

Author: dylan-sutton-chavez

compiler/src/modules/parser/types.rs

@@ -22,7 +22,8 @@ pub enum OpCode {
     BitNot, Shl, Shr, In, NotIn, Is, IsNot, UnpackSequence, BuildTuple, SetupWith, ExitWith, Yield, 
     Del, Assert, Global, Nonlocal, UnpackArgs, ListAppend, SetAdd, MapAdd, BuildSet, RaiseFrom, 
     UnpackEx, LoadEllipsis, Await, MakeCoroutine, YieldFrom, TypeAlias, StoreItem, Dup2, 
-    JumpIfFalseOrPop, JumpIfTrueOrPop, Dup, CallMethod, CallMethodArgs,
+    JumpIfFalseOrPop, JumpIfTrueOrPop, Dup, CallMethod, CallMethodArgs, CallAll, CallAny, CallBin, 
+    CallOct, CallHex, CallDivmod, CallPow, CallRepr, CallReversed, CallCallable, CallId, CallHash,
 }
 
 /* O(1) lookup table mapping Python builtin names to their corresponding OpCodes. */
@@ -51,6 +52,18 @@ pub(super) fn builtin(name: &str) -> Option<(OpCode, bool)> {
         "isinstance" => Some((OpCode::CallIsInstance, true)),
         "chr" => Some((OpCode::CallChr, true)),
         "ord" => Some((OpCode::CallOrd, true)),
+        "all"      => Some((OpCode::CallAll, true)),
+        "any"      => Some((OpCode::CallAny, true)),
+        "bin"      => Some((OpCode::CallBin, true)),
+        "oct"      => Some((OpCode::CallOct, true)),
+        "hex"      => Some((OpCode::CallHex, true)),
+        "divmod"   => Some((OpCode::CallDivmod, true)),
+        "pow"      => Some((OpCode::CallPow, true)),
+        "repr"     => Some((OpCode::CallRepr, true)),
+        "reversed" => Some((OpCode::CallReversed, true)),
+        "callable" => Some((OpCode::CallCallable, true)),
+        "id"       => Some((OpCode::CallId, true)),
+        "hash"     => Some((OpCode::CallHash, true)),
         _ => None,
     }
 }
@@ -262,7 +275,7 @@ impl OpCode {
             BuildList | BuildTuple | BuildDict | BuildSet | BuildSlice | BuildString => OpCategory::Build,
             GetItem | StoreItem | UnpackSequence | UnpackEx | FormatValue => OpCategory::Container,
             ListAppend | SetAdd | MapAdd => OpCategory::Comprehension,
-            Call | MakeFunction | MakeCoroutine | CallPrint | CallLen | CallAbs | CallStr | CallInt | CallRange | CallChr | CallType | CallFloat | CallBool | CallRound | CallMin | CallMax | CallSum | CallSorted | CallEnumerate | CallZip | CallList | CallTuple | CallDict | CallIsInstance | CallSet | CallInput | CallOrd | CallMethod | CallMethodArgs => OpCategory::Function,
+            Call | MakeFunction | MakeCoroutine | CallPrint | CallLen | CallAbs | CallStr | CallInt | CallRange | CallChr | CallType | CallFloat | CallBool | CallRound | CallMin | CallMax | CallSum | CallSorted | CallEnumerate | CallZip | CallList | CallTuple | CallDict | CallIsInstance | CallSet | CallInput | CallOrd | CallMethod | CallMethodArgs  | CallAll | CallAny | CallBin | CallOct | CallHex | CallDivmod | CallPow | CallRepr | CallReversed | CallCallable | CallId | CallHash => OpCategory::Function,
             Phi => OpCategory::Ssa,
             Yield => OpCategory::Yield,
             Assert | Del | Global | Nonlocal | TypeAlias | Import | ImportFrom | SetupExcept | PopExcept | Raise | RaiseFrom | Await | YieldFrom => OpCategory::Side,

compiler/src/modules/vm/builtins.rs

@@ -9,6 +9,48 @@ use core::cell::RefCell;
 use alloc::{string::{String, ToString}, vec::Vec, vec, rc::Rc};
 use crate::modules::fx::FxHashSet as HashSet;
 
+fn i64_to_radix(n: i64, radix: u32, prefix: &str) -> String {
+    if n == 0 {
+        let mut s = String::with_capacity(prefix.len() + 1);
+        s.push_str(prefix); s.push('0'); return s;
+    }
+    let neg = n < 0;
+    let mut abs = (n as i128).unsigned_abs();
+    let mut buf = [0u8; 64];
+    let mut i = buf.len();
+    while abs > 0 {
+        i -= 1;
+        let d = (abs % radix as u128) as u8;
+        buf[i] = if d < 10 { b'0' + d } else { b'a' + d - 10 };
+        abs /= radix as u128;
+    }
+    let mut s = String::with_capacity(prefix.len() + buf.len() - i + 1);
+    if neg { s.push('-'); }
+    s.push_str(prefix);
+    s.push_str(unsafe { core::str::from_utf8_unchecked(&buf[i..]) });
+    s
+}
+
+fn bigint_to_radix(b: &BigInt, radix: u32, prefix: &str) -> String {
+    let mut out = String::new();
+    if b.neg { out.push('-'); }
+    out.push_str(prefix);
+    if b.is_zero() { out.push('0'); return out; }
+
+    let radix_big = BigInt::from_i64(radix as i64);
+    let mut work = b.abs();
+    let mut digits = Vec::<u8>::new();
+    while !work.is_zero() {
+        let (q, r) = work.divmod(&radix_big).unwrap();
+        let d = r.to_i64_checked().unwrap() as u8;
+        digits.push(if d < 10 { b'0' + d } else { b'a' + d - 10 });
+        work = q;
+    }
+    digits.reverse();
+    out.push_str(unsafe { core::str::from_utf8_unchecked(&digits) });
+    out
+}
+
 fn normalize_index(i: i64, len: usize) -> usize {
     (if i < 0 { len as i64 + i } else { i }) as usize
 }
@@ -596,4 +638,207 @@ impl<'a> VM<'a> {
         }
         Ok(())
     }
+
+    // ─── Logical reductions ──────────────────────────────────────────
+
+    pub fn call_all(&mut self, op: u16) -> Result<(), VmErr> {
+        if op != 1 { return Err(cold_type("all() takes exactly 1 argument")); }
+        let o = self.pop()?;
+        let items = self.extract_iter(o, true)?;
+        for v in items {
+            if !self.truthy(v) {
+                self.push(Val::bool(false));
+                return Ok(());
+            }
+        }
+        self.push(Val::bool(true));
+        Ok(())
+    }
+
+    pub fn call_any(&mut self, op: u16) -> Result<(), VmErr> {
+        if op != 1 { return Err(cold_type("any() takes exactly 1 argument")); }
+        let o = self.pop()?;
+        let items = self.extract_iter(o, true)?;
+        for v in items {
+            if self.truthy(v) {
+                self.push(Val::bool(true));
+                return Ok(());
+            }
+        }
+        self.push(Val::bool(false));
+        Ok(())
+    }
+
+    // ─── Number formatting ───────────────────────────────────────────
+
+    pub fn call_bin(&mut self) -> Result<(), VmErr> {
+        let o = self.pop()?;
+        let s = self.int_to_radix_string(o, 2, "0b")?;
+        let v = self.heap.alloc(HeapObj::Str(s))?;
+        self.push(v); Ok(())
+    }
+    pub fn call_oct(&mut self) -> Result<(), VmErr> {
+        let o = self.pop()?;
+        let s = self.int_to_radix_string(o, 8, "0o")?;
+        let v = self.heap.alloc(HeapObj::Str(s))?;
+        self.push(v); Ok(())
+    }
+    pub fn call_hex(&mut self) -> Result<(), VmErr> {
+        let o = self.pop()?;
+        let s = self.int_to_radix_string(o, 16, "0x")?;
+        let v = self.heap.alloc(HeapObj::Str(s))?;
+        self.push(v); Ok(())
+    }
+
+    /// Converts int/BigInt to "<prefix><digits>" with optional sign.
+    fn int_to_radix_string(&self, v: Val, radix: u32, prefix: &str) -> Result<String, VmErr> {
+        if v.is_int() {
+            return Ok(i64_to_radix(v.as_int(), radix, prefix));
+        }
+        if v.is_heap()
+            && let HeapObj::BigInt(b) = self.heap.get(v) {
+                return Ok(bigint_to_radix(b, radix, prefix));
+        }
+        Err(cold_type("integer required"))
+    }
+
+    // ─── Arithmetic ──────────────────────────────────────────────────
+
+    pub fn call_divmod(&mut self) -> Result<(), VmErr> {
+        let b = self.pop()?;
+        let a = self.pop()?;
+        let (Some(ba), Some(bb)) = (self.to_bigint(a), self.to_bigint(b))
+            else { return Err(cold_type("divmod() requires integer operands")); };
+        let (q, r) = ba.divmod(&bb).ok_or(VmErr::ZeroDiv)?;
+        let qv = self.bigint_to_val(q)?;
+        let rv = self.bigint_to_val(r)?;
+        let val = self.heap.alloc(HeapObj::Tuple(vec![qv, rv]))?;
+        self.push(val); Ok(())
+    }
+
+    pub fn call_pow(&mut self, op: u16) -> Result<(), VmErr> {
+        let args = self.pop_n(op as usize)?;
+        match args.len() {
+            2 => {
+                let r = self.pow_2arg(args[0], args[1])?;
+                self.push(r);
+                Ok(())
+            }
+            3 => {
+                // Modular exponentiation: (a ** b) % c
+                let (Some(base), Some(modulus)) =
+                    (self.to_bigint(args[0]), self.to_bigint(args[2]))
+                    else { return Err(cold_type("pow() with 3 args requires integers")); };
+                if !args[1].is_int() {
+                    return Err(cold_type("pow() with 3 args requires integer exponent"));
+                }
+                let mut e = args[1].as_int();
+                if e < 0 { return Err(cold_value("pow() exponent must be non-negative")); }
+                if modulus.is_zero() { return Err(VmErr::ZeroDiv); }
+
+                let mut result = BigInt::from_i64(1);
+                let (_, mut base) = base.divmod(&modulus).unwrap();
+                while e > 0 {
+                    if e & 1 == 1 {
+                        let (_, r) = result.mul(&base).divmod(&modulus).unwrap();
+                        result = r;
+                    }
+                    let (_, b2) = base.mul(&base).divmod(&modulus).unwrap();
+                    base = b2;
+                    e >>= 1;
+                }
+                let r = self.bigint_to_val(result)?;
+                self.push(r);
+                Ok(())
+            }
+            _ => Err(cold_type("pow() takes 2 or 3 arguments")),
+        }
+    }
+
+    fn pow_2arg(&mut self, a: Val, b: Val) -> Result<Val, VmErr> {
+        if let Some(ba) = self.to_bigint(a) && b.is_int() {
+            let exp = b.as_int();
+            if exp >= 0 {
+                if exp > u32::MAX as i64 {
+                    return Err(cold_value("pow() exponent too large"));
+                }
+                return self.bigint_to_val(ba.pow_u32(exp as u32));
+            }
+            return Ok(Val::float(fpowi(ba.to_f64(), exp as i32)));
+        }
+        let to_f = |v: Val| -> Result<f64, VmErr> {
+            if v.is_int() { Ok(v.as_int() as f64) }
+            else if v.is_float() { Ok(v.as_float()) }
+            else { Err(cold_type("pow() requires numeric operands")) }
+        };
+        Ok(Val::float(fpowf(to_f(a)?, to_f(b)?)))
+    }
+
+    // ─── Introspection ───────────────────────────────────────────────
+
+    pub fn call_repr(&mut self) -> Result<(), VmErr> {
+        let o = self.pop()?;
+        let s = self.repr(o);
+        let v = self.heap.alloc(HeapObj::Str(s))?;
+        self.push(v); Ok(())
+    }
+
+    pub fn call_callable(&mut self) -> Result<(), VmErr> {
+        let o = self.pop()?;
+        let result = if o.is_heap() {
+            matches!(self.heap.get(o),
+                HeapObj::Func(..) | HeapObj::BoundMethod(..) | HeapObj::Type(_))
+        } else { false };
+        self.push(Val::bool(result));
+        Ok(())
+    }
+
+    pub fn call_id(&mut self) -> Result<(), VmErr> {
+        let o = self.pop()?;
+        // Use the NaN-boxed bit pattern as identity. Truncate to fit INT_MAX.
+        let id = ((o.0 as i64).abs()) & Val::INT_MAX;
+        self.push(Val::int(id));
+        Ok(())
+    }
+
+    pub fn call_hash(&mut self) -> Result<(), VmErr> {
+        use core::hash::{Hash, Hasher};
+        let o = self.pop()?;
+        let mut h = crate::modules::fx::FxHasher::default();
+        if o.is_int()        { o.as_int().hash(&mut h); }
+        else if o.is_float() { o.as_float().to_bits().hash(&mut h); }
+        else if o.is_bool()  { o.as_bool().hash(&mut h); }
+        else if o.is_none()  { 0u64.hash(&mut h); }
+        else if o.is_heap() {
+            match self.heap.get(o) {
+                HeapObj::Str(s) => s.hash(&mut h),
+                HeapObj::BigInt(b) => { b.neg.hash(&mut h); b.limbs.hash(&mut h); }
+                HeapObj::Tuple(items) => {
+                    for v in items { v.0.hash(&mut h); }
+                }
+                HeapObj::List(_) | HeapObj::Dict(_) | HeapObj::Set(_) => {
+                    return Err(cold_type("unhashable type"));
+                }
+                _ => o.0.hash(&mut h),
+            }
+        }
+        self.push(Val::int(h.finish() as i64 & Val::INT_MAX));
+        Ok(())
+    }
+
+    // ─── Sequence ops ────────────────────────────────────────────────
+
+    pub fn call_reversed(&mut self) -> Result<(), VmErr> {
+        let o = self.pop()?;
+        if !o.is_heap() { return Err(cold_type("reversed() requires a sequence")); }
+        let mut items = if let HeapObj::Str(s) = self.heap.get(o) {
+            let s = s.clone();
+            self.str_to_char_vals(&s)?
+        } else {
+            self.extract_iter(o, true)?
+        };
+        items.reverse();
+        let v = self.heap.alloc(HeapObj::List(Rc::new(RefCell::new(items))))?;
+        self.push(v); Ok(())
+    }
 }

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

@@ -35,6 +35,18 @@ impl<'a> VM<'a> {
             OpCode::CallSet => self.call_set(operand),
             OpCode::CallPrint => { self.mark_impure(); self.call_print(operand) }
             OpCode::CallInput => { self.mark_impure(); self.call_input() }
+            OpCode::CallAll      => self.call_all(operand),
+            OpCode::CallAny      => self.call_any(operand),
+            OpCode::CallBin      => self.call_bin(),
+            OpCode::CallOct      => self.call_oct(),
+            OpCode::CallHex      => self.call_hex(),
+            OpCode::CallDivmod   => self.call_divmod(),
+            OpCode::CallPow      => self.call_pow(operand),
+            OpCode::CallRepr     => self.call_repr(),
+            OpCode::CallReversed => self.call_reversed(),
+            OpCode::CallCallable => self.call_callable(),
+            OpCode::CallId       => self.call_id(),
+            OpCode::CallHash     => self.call_hash(),
             _ => unreachable!("non-function opcode in handle_function"),
         }
     }

compiler/src/modules/vm/mod.rs

@@ -538,7 +538,10 @@ impl<'a> VM<'a> {
             | OpCode::CallList | OpCode::CallTuple | OpCode::CallEnumerate | OpCode::CallIsInstance
             | OpCode::CallRange | OpCode::CallRound | OpCode::CallMin | OpCode::CallMax
             | OpCode::CallSum | OpCode::CallZip | OpCode::CallDict | OpCode::CallSet
-            | OpCode::CallInput | OpCode::MakeFunction | OpCode::MakeCoroutine => {
+            | OpCode::CallInput | OpCode::MakeFunction | OpCode::MakeCoroutine
+            | OpCode::CallAll | OpCode::CallAny | OpCode::CallBin | OpCode::CallOct
+            | OpCode::CallHex | OpCode::CallDivmod | OpCode::CallPow | OpCode::CallRepr
+            | OpCode::CallReversed | OpCode::CallCallable | OpCode::CallId | OpCode::CallHash => {
                 self.handle_function(ins.opcode, op, chunk, slots)?;
             }
 

compiler/tests/cases/vm.json

@@ -425,5 +425,42 @@
   {"src": "def f(a, b):\n    return a + b\nprint(f(**{'a': 1, 'b': 2}))", "output": ["3"], "result": "None"},
   {"src": "def f(a, b, c):\n    return a + b + c\nprint(f(1, **{'b': 2, 'c': 3}))", "output": ["6"], "result": "None"},
   {"src": "def f(a, b, c, d):\n    return a + b + c + d\nprint(f(*[1, 2], **{'c': 3, 'd': 4}))", "output": ["10"], "result": "None"},
-  {"src": "def f(*args):\n    return args\nprint(f(*[1, 2, 3]))", "output": ["[1, 2, 3]"], "result": "None"}
+  {"src": "def f(*args):\n    return args\nprint(f(*[1, 2, 3]))", "output": ["[1, 2, 3]"], "result": "None"},
+  {"src": "print(all([1, 2, 3]))", "output": ["True"], "result": "None"},
+  {"src": "print(all([1, 0, 3]))", "output": ["False"], "result": "None"},
+  {"src": "print(all([]))", "output": ["True"], "result": "None"},
+  {"src": "print(any([0, 0, 1]))", "output": ["True"], "result": "None"},
+  {"src": "print(any([0, 0, 0]))", "output": ["False"], "result": "None"},
+  {"src": "print(any([]))", "output": ["False"], "result": "None"},
+  {"src": "print(bin(5))", "output": ["0b101"], "result": "None"},
+  {"src": "print(bin(0))", "output": ["0b0"], "result": "None"},
+  {"src": "print(bin(-10))", "output": ["-0b1010"], "result": "None"},
+  {"src": "print(oct(8))", "output": ["0o10"], "result": "None"},
+  {"src": "print(oct(0))", "output": ["0o0"], "result": "None"},
+  {"src": "print(hex(255))", "output": ["0xff"], "result": "None"},
+  {"src": "print(hex(16))", "output": ["0x10"], "result": "None"},
+  {"src": "print(hex(-256))", "output": ["-0x100"], "result": "None"},
+  {"src": "print(divmod(7, 3))", "output": ["(2, 1)"], "result": "None"},
+  {"src": "print(divmod(10, 4))", "output": ["(2, 2)"], "result": "None"},
+  {"src": "print(divmod(-7, 3))", "output": ["(-3, 2)"], "result": "None"},
+  {"src": "print(pow(2, 10))", "output": ["1024"], "result": "None"},
+  {"src": "print(pow(3, 5))", "output": ["243"], "result": "None"},
+  {"src": "print(pow(2, 10, 1000))", "output": ["24"], "result": "None"},
+  {"src": "print(pow(7, 13, 19))", "output": ["7"], "result": "None"},
+  {"src": "print(repr('hello'))", "output": ["'hello'"], "result": "None"},
+  {"src": "print(repr(42))", "output": ["42"], "result": "None"},
+  {"src": "print(repr([1, 2, 3]))", "output": ["[1, 2, 3]"], "result": "None"},
+  {"src": "print(reversed([1, 2, 3]))", "output": ["[3, 2, 1]"], "result": "None"},
+  {"src": "print(reversed('abc'))", "output": ["['c', 'b', 'a']"], "result": "None"},
+  {"src": "print(reversed((1, 2, 3)))", "output": ["[3, 2, 1]"], "result": "None"},
+  {"src": "print(callable(str))", "output": ["True"], "result": "None"},
+  {"src": "def f(): pass\nprint(callable(f))", "output": ["True"], "result": "None"},
+  {"src": "print(callable(42))", "output": ["False"], "result": "None"},
+  {"src": "print(callable('hello'))", "output": ["False"], "result": "None"},
+  {"src": "print(callable(int))", "output": ["True"], "result": "None"},
+  {"src": "x = 42\nprint(id(x) == id(x))", "output": ["True"], "result": "None"},
+  {"src": "print(hash(42) == hash(42))", "output": ["True"], "result": "None"},
+  {"src": "print(hash('hello') == hash('hello'))", "output": ["True"], "result": "None"},
+  {"src": "print(hash((1, 2, 3)) == hash((1, 2, 3)))", "output": ["True"], "result": "None"},
+  {"src": "hash([1, 2, 3])", "output": [], "result": "None", "error": "unhashable type"}
 ]