Switch from tree-walking to bytecode VM for ALL execution

Author: 0xhenrique

src/compiler.rs

@@ -692,6 +692,68 @@ impl Compiler {
         self.compile_expr(&args[args.len() - 1], dest, tail_pos)
     }
 
+    /// Try to compile a binary operation using specialized opcodes
+    /// Returns Some(true) if compiled, Some(false) if not applicable, Err on error
+    fn try_compile_binary_op(&mut self, op: &str, args: &[Value], dest: Reg) -> Result<Option<bool>, String> {
+        // Binary arithmetic/comparison operators
+        if args.len() == 2 {
+            let make_binary_op: Option<fn(Reg, Reg, Reg) -> Op> = match op {
+                "+" => Some(Op::Add),
+                "-" => Some(Op::Sub),
+                "*" => Some(Op::Mul),
+                "/" => Some(Op::Div),
+                "mod" => Some(Op::Mod),
+                "<" => Some(Op::Lt),
+                "<=" => Some(Op::Le),
+                ">" => Some(Op::Gt),
+                ">=" => Some(Op::Ge),
+                "=" => Some(Op::Eq),
+                "!=" => Some(Op::Ne),
+                _ => None,
+            };
+
+            if let Some(make_op) = make_binary_op {
+                // Compile both arguments
+                let a_reg = self.alloc_reg();
+                self.compile_expr(&args[0], a_reg, false)?;
+                let b_reg = self.alloc_reg();
+                self.compile_expr(&args[1], b_reg, false)?;
+
+                // Emit the operation
+                self.emit(make_op(dest, a_reg, b_reg));
+
+                // Free temp registers
+                self.free_reg();
+                self.free_reg();
+
+                return Ok(Some(true));
+            }
+        }
+
+        // Unary operators
+        if args.len() == 1 {
+            if op == "not" {
+                let a_reg = self.alloc_reg();
+                self.compile_expr(&args[0], a_reg, false)?;
+                self.emit(Op::Not(dest, a_reg));
+                self.free_reg();
+                return Ok(Some(true));
+            }
+
+            // Unary minus: (- x)
+            if op == "-" {
+                let a_reg = self.alloc_reg();
+                self.compile_expr(&args[0], a_reg, false)?;
+                self.emit(Op::Neg(dest, a_reg));
+                self.free_reg();
+                return Ok(Some(true));
+            }
+        }
+
+        // Not a specialized operation
+        Ok(None)
+    }
+
     fn compile_call(&mut self, items: &[Value], dest: Reg, tail_pos: bool) -> Result<(), String> {
         // Try constant folding for the entire call expression (including pure user functions)
         let call_expr = Value::list(items.to_vec());
@@ -701,6 +763,15 @@ impl Compiler {
             return Ok(());
         }
 
+        // Try to compile as specialized binary operation
+        if let Some(op) = items[0].as_symbol() {
+            if let Some(result) = self.try_compile_binary_op(op, &items[1..], dest)? {
+                if result {
+                    return Ok(());
+                }
+            }
+        }
+
         let func_reg = self.alloc_reg();
 
         // Compile function
@@ -863,11 +934,15 @@ mod tests {
 
     #[test]
     fn test_no_fold_with_variables() {
-        // If any arg is not a constant, don't fold
+        // If any arg is not a constant, don't fold to LoadConst
         let chunk = compile_str("(+ x 1)").unwrap();
-        // Should have a call, not just LoadConst
-        let has_call = chunk.code.iter().any(|op| matches!(op, Op::Call(_, _, _) | Op::TailCall(_, _)));
-        assert!(has_call);
+        // Should use Op::Add (specialized opcode), not fold to LoadConst
+        let has_add = chunk.code.iter().any(|op| matches!(op, Op::Add(_, _, _)));
+        assert!(has_add, "Expected Op::Add for (+ x 1)");
+        // Should NOT have LoadConst as first instruction (that would mean folding)
+        // First instruction should be GetGlobal for 'x'
+        let first_is_get_global = matches!(chunk.code[0], Op::GetGlobal(_, _));
+        assert!(first_is_get_global, "First op should be GetGlobal for variable x");
     }
 
     #[test]

src/lib.rs

@@ -6,25 +6,25 @@ pub mod parser;
 pub mod value;
 pub mod vm;
 
+pub use compiler::Compiler;
 pub use eval::{eval, standard_env, Env};
 pub use macros::{expand, MacroRegistry};
 pub use parser::{parse, parse_all};
 pub use value::Value;
+pub use vm::{standard_vm, VM};
 
-/// Convenience function to evaluate a string in a standard environment
+/// Convenience function to evaluate a string using the bytecode VM
 pub fn run(input: &str) -> Result<Value, String> {
     let expr = parse(input)?;
-    let env = standard_env();
-    eval(&expr, &env)
+    let chunk = Compiler::compile(&expr)?;
+    let mut vm = standard_vm();
+    vm.run(chunk)
 }
 
-/// Convenience function to evaluate multiple expressions
+/// Convenience function to evaluate multiple expressions using the bytecode VM
 pub fn run_all(input: &str) -> Result<Value, String> {
     let exprs = parse_all(input)?;
-    let env = standard_env();
-    let mut result = Value::Nil;
-    for expr in exprs {
-        result = eval(&expr, &env)?;
-    }
-    Ok(result)
+    let chunk = Compiler::compile_all(&exprs)?;
+    let mut vm = standard_vm();
+    vm.run(chunk)
 }

src/main.rs

@@ -1,4 +1,4 @@
-use lisp_vm::{eval, expand, parse, parse_all, standard_env, MacroRegistry, Value};
+use lisp_vm::{expand, parse, parse_all, standard_env, standard_vm, Compiler, MacroRegistry, Value};
 use std::env;
 use std::fs;
 use std::io::{self, BufRead, Write};
@@ -25,25 +25,38 @@ fn run_file(filename: &str) -> Result<Value, String> {
         .map_err(|e| format!("Could not read file '{}': {}", filename, e))?;
 
     let exprs = parse_all(&contents)?;
+
+    // For macro expansion, we still need the tree-walking environment
     let env = standard_env();
     let macros = MacroRegistry::new();
 
-    let mut result = Value::Nil;
-    for expr in exprs {
-        let expanded = expand(&expr, &macros, &env)?;
-        result = eval(&expanded, &env)?;
-    }
+    // Expand macros on all expressions first
+    let expanded: Result<Vec<Value>, String> = exprs
+        .iter()
+        .map(|expr| expand(expr, &macros, &env))
+        .collect();
+    let expanded = expanded?;
+
+    // Compile all expressions to bytecode
+    let chunk = Compiler::compile_all(&expanded)?;
 
-    Ok(result)
+    // Execute via bytecode VM
+    let mut vm = standard_vm();
+    vm.run(chunk)
 }
 
 fn run_repl() {
-    println!("Lisp VM v0.1.0");
+    println!("Lisp VM v0.1.0 (bytecode)");
     println!("Type :q or :quit to exit.");
     println!();
 
+    // For macro expansion, we still need the tree-walking environment
     let env = standard_env();
     let macros = MacroRegistry::new();
+
+    // Create a single VM instance to maintain globals across expressions
+    let mut vm = standard_vm();
+
     let stdin = io::stdin();
     let mut stdout = io::stdout();
 
@@ -66,17 +79,26 @@ fn run_repl() {
 
                 match parse(line) {
                     Ok(expr) => {
-                        // First expand macros, then evaluate
+                        // First expand macros
                         match expand(&expr, &macros, &env) {
-                            Ok(expanded) => match eval(&expanded, &env) {
-                                Ok(result) => {
-                                    // Don't display nil results (common REPL behavior)
-                                    if !result.is_nil() {
-                                        println!("{}", result);
+                            Ok(expanded) => {
+                                // Compile to bytecode
+                                match Compiler::compile(&expanded) {
+                                    Ok(chunk) => {
+                                        // Execute via VM
+                                        match vm.run(chunk) {
+                                            Ok(result) => {
+                                                // Don't display nil results (common REPL behavior)
+                                                if !result.is_nil() {
+                                                    println!("{}", result);
+                                                }
+                                            }
+                                            Err(e) => eprintln!("Error: {}", e),
+                                        }
                                     }
+                                    Err(e) => eprintln!("Compile error: {}", e),
                                 }
-                                Err(e) => eprintln!("Error: {}", e),
-                            },
+                            }
                             Err(e) => eprintln!("Macro error: {}", e),
                         }
                     }

src/vm.rs

@@ -4,8 +4,8 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::rc::Rc;
 
-const MAX_REGISTERS: usize = 256;
-const MAX_FRAMES: usize = 256;
+const MAX_REGISTERS: usize = 8192;  // Increased for deep recursion (fib needs ~30 depth)
+const MAX_FRAMES: usize = 1024;
 
 #[derive(Clone)]
 struct CallFrame {
@@ -565,6 +565,50 @@ pub fn standard_vm() -> VM {
         Ok(Value::Nil)
     }));
 
+    // Type predicates
+    vm.define_global("nil?", native("nil?", |args| {
+        if args.len() != 1 { return Err("nil? expects 1 argument".to_string()); }
+        Ok(Value::Bool(matches!(args[0], Value::Nil)))
+    }));
+
+    vm.define_global("int?", native("int?", |args| {
+        if args.len() != 1 { return Err("int? expects 1 argument".to_string()); }
+        Ok(Value::Bool(matches!(args[0], Value::Int(_))))
+    }));
+
+    vm.define_global("float?", native("float?", |args| {
+        if args.len() != 1 { return Err("float? expects 1 argument".to_string()); }
+        Ok(Value::Bool(matches!(args[0], Value::Float(_))))
+    }));
+
+    vm.define_global("string?", native("string?", |args| {
+        if args.len() != 1 { return Err("string? expects 1 argument".to_string()); }
+        Ok(Value::Bool(matches!(args[0], Value::String(_))))
+    }));
+
+    vm.define_global("list?", native("list?", |args| {
+        if args.len() != 1 { return Err("list? expects 1 argument".to_string()); }
+        Ok(Value::Bool(matches!(args[0], Value::List(_))))
+    }));
+
+    vm.define_global("fn?", native("fn?", |args| {
+        if args.len() != 1 { return Err("fn? expects 1 argument".to_string()); }
+        Ok(Value::Bool(matches!(args[0], Value::Function(_) | Value::NativeFunction(_) | Value::CompiledFunction(_))))
+    }));
+
+    vm.define_global("symbol?", native("symbol?", |args| {
+        if args.len() != 1 { return Err("symbol? expects 1 argument".to_string()); }
+        Ok(Value::Bool(matches!(args[0], Value::Symbol(_))))
+    }));
+
+    // Symbol operations (useful for macros)
+    vm.define_global("gensym", native("gensym", |_args| {
+        use std::sync::atomic::{AtomicU64, Ordering};
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        let id = COUNTER.fetch_add(1, Ordering::SeqCst);
+        Ok(Value::symbol(&format!("G__{}", id)))
+    }));
+
     vm
 }