Add Op::CONS (opcode 50) with ABC format: dest, car, cdr

Add VM handler that creates cons cells directly
Update compiler to detect (cons ...) calls and emit spec opcode

Author: 0xhenrique

src/bytecode.rs

@@ -70,6 +70,7 @@ impl std::fmt::Debug for Op {
             Self::JUMP_IF_GE_IMM => write!(f, "JumpIfGeImm({}, {}, {})", self.a(), self.b() as i8, self.c() as i8),
             Self::JUMP_IF_NIL => write!(f, "JumpIfNil({}, {})", self.a(), self.sbx()),
             Self::JUMP_IF_NOT_NIL => write!(f, "JumpIfNotNil({}, {})", self.a(), self.sbx()),
+            Self::CONS => write!(f, "Cons({}, {}, {})", self.a(), self.b(), self.c()),
             _ => write!(f, "Unknown(0x{:08x})", self.0),
         }
     }
@@ -129,6 +130,8 @@ impl Op {
     // Specialized nil check opcodes (common in list processing)
     pub const JUMP_IF_NIL: u8 = 48;    // A: src, sBx: offset - jump if src is nil
     pub const JUMP_IF_NOT_NIL: u8 = 49; // A: src, sBx: offset - jump if src is NOT nil
+    // Specialized cons opcode (very common in list construction)
+    pub const CONS: u8 = 50;           // ABC: dest, car, cdr - create cons cell
 
     // ========== Constructors ==========
 
@@ -445,6 +448,12 @@ impl Op {
         Self::asbx(Self::JUMP_IF_NOT_NIL, src, offset)
     }
 
+    // Specialized cons (very common in list construction)
+    #[inline(always)]
+    pub const fn cons(dest: Reg, car: Reg, cdr: Reg) -> Self {
+        Self::abc(Self::CONS, dest, car, cdr)
+    }
+
     // ========== Jump patching helpers ==========
 
     /// Check if this is a jump instruction (for patching)

src/compiler.rs

@@ -949,6 +949,19 @@ impl Compiler {
                     _ => {}
                 }
             }
+
+            // Try specialized cons opcode (two arguments)
+            if args.len() == 2 && op == "cons" {
+                // Compile car into dest
+                self.compile_expr(&args[0], dest, false)?;
+                // Compile cdr into temp register
+                let cdr_reg = self.alloc_reg();
+                self.compile_expr(&args[1], cdr_reg, false)?;
+                // Emit Cons
+                self.emit(Op::cons(dest, dest, cdr_reg));
+                self.free_reg(); // free cdr_reg
+                return Ok(());
+            }
         }
 
         // Check if calling a global symbol (optimization: use CallGlobal/TailCallGlobal)

src/vm.rs

@@ -908,6 +908,17 @@ impl VM {
                     }
                 }
 
+                // Specialized cons opcode (very common in list construction)
+                Op::CONS => {
+                    let dest = instr.a();
+                    let car_reg = instr.b();
+                    let cdr_reg = instr.c();
+                    let car = unsafe { self.registers.get_unchecked(base + car_reg as usize).clone() };
+                    let cdr = unsafe { self.registers.get_unchecked(base + cdr_reg as usize).clone() };
+                    let cons = Value::cons(car, cdr);
+                    unsafe { *self.registers.get_unchecked_mut(base + dest as usize) = cons };
+                }
+
                 _ => {
                     return Err(format!("Unknown opcode: {}", instr.opcode()));
                 }
@@ -1539,4 +1550,38 @@ mod tests {
             (list-sum (cons 1 (cons 2 (cons 3 (cons 4 (cons 5 nil))))) 0))").unwrap();
         assert_eq!(result, Value::Int(15));
     }
+
+    #[test]
+    fn test_specialized_cons() {
+        // Test specialized cons opcode
+        // Basic cons
+        let result = vm_eval("(cons 1 nil)").unwrap();
+        let cons = result.as_cons().expect("expected cons cell");
+        assert_eq!(cons.car.as_int(), Some(1));
+        assert!(cons.cdr.is_nil());
+
+        // Nested cons
+        let result = vm_eval("(cons 1 (cons 2 (cons 3 nil)))").unwrap();
+        let cons = result.as_cons().expect("expected cons cell");
+        assert_eq!(cons.car.as_int(), Some(1));
+
+        // List reversal using cons (exercises the opcode heavily)
+        let result = vm_eval("(do
+            (def reverse-acc (fn (lst acc)
+                (if (nil? lst)
+                    acc
+                    (reverse-acc (cdr lst) (cons (car lst) acc)))))
+            (reverse-acc (cons 1 (cons 2 (cons 3 nil))) nil))").unwrap();
+        let cons = result.as_cons().expect("expected cons cell");
+        assert_eq!(cons.car.as_int(), Some(3));
+
+        // Map function using cons
+        let result = vm_eval("(do
+            (def map-double (fn (lst)
+                (if (nil? lst)
+                    nil
+                    (cons (* 2 (car lst)) (map-double (cdr lst))))))
+            (car (map-double (cons 5 (cons 10 nil)))))").unwrap();
+        assert_eq!(result, Value::Int(10)); // first element 5 * 2 = 10
+    }
 }