Feat: Implement 'BigInt' type, including fixes for missaligned types and tests.

Author: dylan-sutton-chavez

compiler/README.md

@@ -1,6 +1,6 @@
 ## Edge Python
 
-Single-pass SSA compiler for Python on the edge computing: hand-written lexer, token-to-bytecode parser, adaptive virtual machine with NaN-boxed values, inline caching, template memoization, mark-sweep garbage collector, and configurable sandbox limits. Native and WASM targets.
+Single-pass SSA compiler for Python 3.13: hand-written lexer, token-to-bytecode parser, adaptive virtual machine with NaN-boxed values, inline caching, template memoization, mark-sweep garbage collector, and configurable sandbox limits. Native and WASM targets.
 
 ---
 
@@ -74,7 +74,7 @@ print(counter)
 
 ### Value Representation
 
-NaN-boxed 64-bit: integers are 48-bit signed ($\pm 2^{47}$), overflow promotes to float (Gudeman, 1993). Results exceeding 48-bit range lose integer precision, consistent with Lua 5.3 and PHP 8. Heap index is 28-bit ($2^{28}$ objects max, returns `MemoryError` beyond).
+NaN-boxed 64-bit: integers are 48-bit signed ($\pm 2^{47}$) for inline storage; values outside this range are heap-allocated as arbitrary-precision `BigInt` (base-$2^{32}$ limb array, sign-magnitude), matching Python's unbounded `int` semantics. True division (`/`) always yields `float`. Heap index is 28-bit ($2^{28}$ objects max, returns `MemoryError` beyond).
 
 ### Building for WebAssembly
 
@@ -147,4 +147,4 @@ cargo test --features wasm-tests
 
 ### License
 
-MIT OR Apache-2.0
+MIT OR Apache-2.0

compiler/src/main.rs

@@ -55,7 +55,7 @@ fn run(path: &str, _q: bool, sandbox: bool) -> Result<(), String> {
 }
 
 fn main() {
-    let (p, v, q, sandbox) = parse_args();
+    let (p, _v, q, sandbox) = parse_args();
 
     let default_level = if q { "error" } else { "info" };
     env_logger::Builder::from_env(env_logger::Env::default().default_filter_or(default_level)).init();

compiler/src/modules/parser/expr.rs

@@ -243,18 +243,57 @@ impl<'src, I: Iterator<Item = Token>> Parser<'src, I> {
         let s = raw.replace('_', "");
         if kind == TokenType::Float {
             self.emit_const(Value::Float(s.parse().unwrap_or(0.0)));
-        } else {
-            let v = if let Some(s) = s.strip_prefix("0x").or(s.strip_prefix("0X")) {
-                i64::from_str_radix(s, 16).unwrap_or(0)
-            } else if let Some(s) = s.strip_prefix("0o").or(s.strip_prefix("0O")) {
-                i64::from_str_radix(s, 8).unwrap_or(0)
-            } else if let Some(s) = s.strip_prefix("0b").or(s.strip_prefix("0B")) {
-                i64::from_str_radix(s, 2).unwrap_or(0)
+            return;
+        }
+        let maybe: Option<i64> =
+            if let Some(h) = s.strip_prefix("0x").or(s.strip_prefix("0X")) {
+                i64::from_str_radix(h, 16).ok()
+            } else if let Some(o) = s.strip_prefix("0o").or(s.strip_prefix("0O")) {
+                i64::from_str_radix(o, 8).ok()
+            } else if let Some(b) = s.strip_prefix("0b").or(s.strip_prefix("0B")) {
+                i64::from_str_radix(b, 2).ok()
             } else {
-                s.parse().unwrap_or(0)
+                s.parse().ok()
             };
-            self.emit_const(Value::Int(v));
+
+        match maybe {
+            Some(v) => self.emit_const(Value::Int(v)),
+            None => {
+                let dec =
+                    if let Some(h) = s.strip_prefix("0x").or(s.strip_prefix("0X")) {
+                        Self::big_base_to_dec(h, 16)
+                    } else if let Some(o) = s.strip_prefix("0o").or(s.strip_prefix("0O")) {
+                        Self::big_base_to_dec(o, 8)
+                    } else if let Some(b) = s.strip_prefix("0b").or(s.strip_prefix("0B")) {
+                        Self::big_base_to_dec(b, 2)
+                    } else {
+                        s
+                    };
+                self.emit_const(Value::BigInt(dec));
+            }
+        }
+    }
+
+    fn big_base_to_dec(s: &str, base: u32) -> String {
+        const DEC: u64 = 1_000_000_000;
+        let mut limbs: Vec<u32> = vec![0];
+        for c in s.chars() {
+            let d = c.to_digit(base).unwrap_or(0) as u64;
+            let mut carry = d;
+            for limb in limbs.iter_mut() {
+                let cur = *limb as u64 * base as u64 + carry;
+                *limb = (cur % DEC) as u32;
+                carry = cur / DEC;
+            }
+            if carry != 0 { limbs.push(carry as u32); }
+        }
+        let mut out = String::new();
+        for (i, &l) in limbs.iter().rev().enumerate() {
+            if i == 0 { out.push_str(&format!("{}", l)); }
+            else { out.push_str(&format!("{:09}", l)); }
         }
+        if out.is_empty() { out.push('0'); }
+        out
     }
 
     /*

compiler/src/modules/parser/types.rs

@@ -67,6 +67,7 @@ Value
 pub enum Value {
     Str(String),
     Int(i64),
+    BigInt(String),
     Float(f64),
     Bool(bool),
     None,

compiler/src/modules/vm/builtins.rs

@@ -48,10 +48,21 @@ impl<'a> VM<'a> {
         let o = self.pop()?;
         if o.is_int() {
             let r = (o.as_int() as i128).abs();
-            self.push(if r <= Val::INT_MAX as i128 { Val::int(r as i64) } else { Val::float(r as f64) });
+            let v = self.i128_to_val(r)?;
+            self.push(v);
+        } else if o.is_float() {
+            self.push(Val::float(o.as_float().abs()));
+        } else if o.is_heap() {
+            if let HeapObj::BigInt(b) = self.heap.get(o) {
+                let ab = b.abs();
+                let v = self.bigint_to_val(ab)?;
+                self.push(v);
+            } else {
+                return Err(VmErr::Type("abs()".into()));
+            }
+        } else {
+            return Err(VmErr::Type("abs()".into()));
         }
-        else if o.is_float() { self.push(Val::float(o.as_float().abs())); }
-        else { return Err(VmErr::Type("abs()".into())); }
         Ok(())
     }
 
@@ -72,6 +83,16 @@ impl<'a> VM<'a> {
 
     pub fn call_int(&mut self) -> Result<(), VmErr> {
         let o = self.pop()?;
+        if o.is_heap() {
+            if let HeapObj::BigInt(b) = self.heap.get(o) {
+                let pushed = {
+                    let b = b.clone();
+                    self.bigint_to_val(b)?
+                };
+                self.push(pushed);
+                return Ok(());
+            }
+        }
         let i = if o.is_int() { o.as_int() }
             else if o.is_float() { o.as_float() as i64 }
             else if o.is_bool() { o.as_bool() as i64 }
@@ -80,7 +101,8 @@ impl<'a> VM<'a> {
                 _ => return Err(VmErr::Type("int()".into())),
             }}
             else { return Err(VmErr::Type("int()".into())); };
-        self.push(Val::int(i)); Ok(())
+        let v = self.bigint_to_val(BigInt::from_i64(i))?;
+        self.push(v); Ok(())
     }
 
     /*
@@ -94,7 +116,8 @@ impl<'a> VM<'a> {
             else if o.is_int() { o.as_int() as f64 }
             else if o.is_heap() { match self.heap.get(o) {
                 HeapObj::Str(s) => s.trim().parse().map_err(|_| VmErr::Value(format!("float: '{}'", s)))?,
-                _ => return Err(VmErr::Type("float()".into())),
+                HeapObj::BigInt(b) => b.to_f64(),
+                _ => return Err(VmErr::Type("float()".into()))
             }}
             else { return Err(VmErr::Type("float()".into())); };
         self.push(Val::float(f)); Ok(())
@@ -105,8 +128,12 @@ impl<'a> VM<'a> {
     }
 
     pub fn call_type(&mut self) -> Result<(), VmErr> {
-        let o = self.pop()?; let s = self.type_name(o);
-        let v = self.heap.alloc(HeapObj::Str(s.into()))?; self.push(v); Ok(())
+        let o = self.pop()?;
+        let s = self.type_name(o);
+        let full = format!("<class '{}'>", s);
+        let v = self.heap.alloc(HeapObj::Str(full))?;
+        self.push(v);
+        Ok(())
     }
 
     pub fn call_chr(&mut self) -> Result<(), VmErr> {
@@ -164,6 +191,7 @@ impl<'a> VM<'a> {
             }
             (Some(o), None) if o.is_float() => Val::int(fround(o.as_float()) as i64),
             (Some(o), _) if o.is_int() => *o,
+            (Some(o), _) if o.is_heap() && matches!(self.heap.get(*o), HeapObj::BigInt(_)) => *o,
             _ => return Err(VmErr::Type("round()".into())),
         };
         self.push(v); Ok(())

compiler/src/modules/vm/cache.rs

@@ -71,6 +71,7 @@ fn eq_vals_heap(a: Val, b: Val, heap: &super::types::HeapPool) -> bool {
     if !a.is_heap() || !b.is_heap() { return a.0 == b.0; }
     // Content-based Val comparison for cache lookups, recursing into collections.
     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_heap(a,b,heap)),
         (HeapObj::List(x),  HeapObj::List(y))  => eq_seq(&x.borrow(), &y.borrow(), |a,b| eq_vals_heap(a,b,heap)),

compiler/src/modules/vm/mod.rs

@@ -128,7 +128,14 @@ impl<'a> VM<'a> {
 
     pub(crate) fn to_val(&mut self, v: &Value) -> Result<Val, VmErr> {
         Ok(match v {
-            Value::Int(i) => Val::int_checked(*i).unwrap_or_else(|| Val::float(*i as f64)),
+            Value::Int(i) => {
+                if *i >= Val::INT_MIN && *i <= Val::INT_MAX {
+                    Val::int(*i)
+                } else {
+                    self.heap.alloc(HeapObj::BigInt(BigInt::from_i64(*i)))?
+                }
+            }
+            Value::BigInt(s) => self.heap.alloc(HeapObj::BigInt(BigInt::from_decimal(s)))?,
             Value::Float(f) => Val::float(*f),
             Value::Bool(b) => Val::bool(*b),
             Value::None => Val::none(),
@@ -252,57 +259,64 @@ impl<'a> VM<'a> {
                 OpCode::Mul => { let (a, b) = self.pop2()?; cached_binop!(self.heap, rip, &ins.opcode, a, b, cache, adaptive); let v = self.mul_vals(a, b)?; self.push(v); }
                 OpCode::Div => { let (a, b) = self.pop2()?; let v = self.div_vals(a, b)?; self.push(v); }
                 OpCode::Mod => {
-                    let (a, b) = self.pop2()?;
-                    if !a.is_int() || !b.is_int() { return Err(VmErr::Type("mod requires int".into())); }
-                    let d = b.as_int(); if d == 0 { return Err(VmErr::ZeroDiv); }
-                    let r = a.as_int() % d;
-                    self.push(Val::int(if r != 0 && (r < 0) != (d < 0) { r + d } else { r }));
+                let (a, b) = self.pop2()?;
+                if let (Some(ba), Some(bb)) = (self.to_bigint(a), self.to_bigint(b)) {
+                    let (_, r) = ba.divmod(&bb).ok_or(VmErr::ZeroDiv)?;
+                    let v = self.bigint_to_val(r)?;
+                    self.push(v);
+                } else {
+                    return Err(VmErr::Type("mod requires int".into()));
+                }
                 }
                 OpCode::Pow => {
                     let (a, b) = self.pop2()?;
-                    let v = match (a.is_int(), b.is_int()) {
-                        (true, true) => {
+                    if let Some(ba) = self.to_bigint(a) {
+                        if b.is_int() {
                             let exp = b.as_int();
                             if exp >= 0 {
-                                match (a.as_int() as i128).checked_pow(exp as u32) {
-                                    Some(result) if result >= Val::INT_MIN as i128
-                                                && result <= Val::INT_MAX as i128 => Val::int(result as i64),
-                                    Some(result) => Val::float(result as f64),
-                                    None => Val::float(fpowi(a.as_int() as f64, exp as i32)),
-                                }
-                            } else {
-                                Val::float(fpowi(a.as_int() as f64, exp as i32))
+                                let result = ba.pow_u32(exp as u32);
+                                let v = self.bigint_to_val(result)?;
+                                self.push(v);
+                                continue;
                             }
+                            self.push(Val::float(fpowi(ba.to_f64(), exp as i32)));
+                            continue;
                         }
-                        _ => {
-                            let fa = if a.is_int() { a.as_int() as f64 } else if a.is_float() { a.as_float() }
-                                    else { return Err(VmErr::Type("'**' requires numeric operands".into())); };
-                            let fb = if b.is_int() { b.as_int() as f64 } else if b.is_float() { b.as_float() }
-                                    else { return Err(VmErr::Type("'**' requires numeric operands".into())); };
-                            Val::float(fpowf(fa, fb))
-                        }
-                    };
-                    self.push(v);
+                    }
+                    let fa = if a.is_int() { a.as_int() as f64 } else if a.is_float() { a.as_float() }
+                            else { return Err(VmErr::Type("'**' requires numeric operands".into())); };
+                    let fb = if b.is_int() { b.as_int() as f64 } else if b.is_float() { b.as_float() }
+                            else { return Err(VmErr::Type("'**' requires numeric operands".into())); };
+                    self.push(Val::float(fpowf(fa, fb)));
                 }
                 OpCode::FloorDiv => {
                     let (a, b) = self.pop2()?;
-                    if !a.is_int() || !b.is_int() { return Err(VmErr::Type("// requires int".into())); }
-                    let d = b.as_int(); if d == 0 { return Err(VmErr::ZeroDiv); }
-                    let (q, r) = (a.as_int() / d, a.as_int() % d);
-                    self.push(Val::int(if r != 0 && (r < 0) != (d < 0) { q - 1 } else { q }));
+                    if let (Some(ba), Some(bb)) = (self.to_bigint(a), self.to_bigint(b)) {
+                        let (q, _) = ba.divmod(&bb).ok_or(VmErr::ZeroDiv)?;
+                        let v = self.bigint_to_val(q)?;
+                        self.push(v);
+                    } else {
+                        return Err(VmErr::Type("// requires int".into()));
+                    }
                 }
                 OpCode::Minus => {
                     let v = self.pop()?;
                     if v.is_int() {
-                        let r = -(v.as_int() as i128);
-                        self.push(if r >= Val::INT_MIN as i128 && r <= Val::INT_MAX as i128 {
-                            Val::int(r as i64)
+                        let pushed = self.i128_to_val(-(v.as_int() as i128))?;
+                        self.push(pushed);
+                    } else if v.is_float() {
+                        self.push(Val::float(-v.as_float()));
+                    } else if v.is_heap() {
+                        if let HeapObj::BigInt(b) = self.heap.get(v) {
+                            let neg = b.neg();
+                            let pushed = self.bigint_to_val(neg)?;
+                            self.push(pushed);
                         } else {
-                            Val::float(r as f64)
-                        });
+                            return Err(VmErr::Type("unary -".into()));
+                        }
+                    } else {
+                        return Err(VmErr::Type("unary -".into()));
                     }
-                    else if v.is_float() { self.push(Val::float(-v.as_float())); }
-                    else { return Err(VmErr::Type("unary -".into())); }
                 }
 
                 // Bitwise