feat: recursion

runtime/src/bytecode.rs

@@ -44,6 +44,7 @@ pub enum Instruction {
     StoreLocal(usize),
     LoadLocal(usize),
     LoadFree(usize),
+    CurrentClosure,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]

runtime/src/compiler/mod.rs

@@ -466,10 +466,12 @@ impl Compiler {
         fn_literal: &ast::FunctionLiteral,
         range: Range,
     ) -> Result<(), Error> {
-        // TODO: Do something with recursion
-
         self.enter_scope();
 
+        if let Some(name) = &fn_literal.name {
+            self.symbol_table.define_current_closure(name.to_string());
+        }
+
         // Define argument symbols
         for param in &fn_literal.parameters {
             self.symbol_table.define(param.to_string());
@@ -524,6 +526,7 @@ impl Compiler {
             Symbol::Global(index) => self.emit(Instruction::StoreGlobal(index), range),
             Symbol::Local(index) => self.emit(Instruction::StoreLocal(index), range),
             Symbol::Free(_) => panic!("Can't store to free symbol"),
+            Symbol::CurrentClosure => panic!("Can't store to current closure symbol"),
         };
     }
 
@@ -532,6 +535,7 @@ impl Compiler {
             Symbol::Global(index) => self.emit(Instruction::LoadGlobal(index), range),
             Symbol::Local(index) => self.emit(Instruction::LoadLocal(index), range),
             Symbol::Free(index) => self.emit(Instruction::LoadFree(index), range),
+            Symbol::CurrentClosure => self.emit(Instruction::CurrentClosure, range),
         };
     }
 }

runtime/src/compiler/symbol_table.rs

@@ -5,6 +5,7 @@ pub enum Symbol {
     Global(usize),
     Local(usize),
     Free(usize),
+    CurrentClosure,
 }
 
 #[derive(Debug)]
@@ -40,6 +41,17 @@ impl SymbolTable {
             .expect("Symbol table should have at least one store")
     }
 
+    pub fn define_current_closure(&mut self, name: String) -> Symbol {
+        let symbol = Symbol::CurrentClosure;
+
+        self.0
+            .last_mut()
+            .expect("Symbol table should have at least one store")
+            .store
+            .insert(name, symbol);
+        symbol
+    }
+
     pub fn define(&mut self, name: String) -> Symbol {
         let is_global = self.0.len() == 1;
 

runtime/src/error.rs

@@ -29,6 +29,7 @@ pub enum ErrorKind {
     InvalidOrderingType(DataType, DataType),
     InvalidEqualityType(DataType, DataType),
     InvalidFunctionCalee(DataType),
+    InvalidNrOfArgs { expected: usize, got: usize },
 }
 
 #[derive(Debug, Error, PartialEq)]
@@ -104,6 +105,7 @@ impl Display for ErrorKind {
             ),
             ErrorKind::ReturnOutsideOfFunction => write!(f, "Return can't be used outside of a function."),
             ErrorKind::InvalidFunctionCalee(dt) => write!(f,"Can only call functions, not {dt}"),
+            ErrorKind::InvalidNrOfArgs { expected, got } =>write!(f, "Invalid number of arguments, expected: {expected}, got: {got}")
         }
     }
 }

runtime/src/vm/mod.rs

@@ -195,6 +195,10 @@ impl VirtualMachine {
             Instruction::StoreLocal(index) => self.store_local(index),
             Instruction::LoadLocal(index) => self.load_local(index)?,
             Instruction::LoadFree(index) => self.load_free(index)?,
+            Instruction::CurrentClosure => {
+                let closure = self.current_frame().closure.clone();
+                self.push(Object::Closure(closure))?;
+            }
         }
 
         Ok(Some(ip + 1))
@@ -598,7 +602,10 @@ impl VirtualMachine {
 
         let fun = &functions[closure.function_index];
         if fun.nr_arguments != nr_args {
-            todo!("return error");
+            return Err(ErrorKind::InvalidNrOfArgs {
+                expected: fun.nr_arguments,
+                got: nr_args,
+            });
         }
 
         let nr_local = fun.nr_local_variables;

runtime/src/vm/test.rs

@@ -515,3 +515,61 @@ fn call_closure() {
         run_test(input, Ok(expected));
     }
 }
+
+#[test]
+fn recursion() {
+    let tests = [
+        (
+            r#"
+            fib = fn(n) {
+                if (n <= 2) {
+                    return 1
+                } else {
+                    return fib(n-1) + fib(n-2)
+                }
+            }
+
+            fib(5)
+            "#,
+            Object::Integer(5),
+        ),
+        (
+            r#"
+            wrap = fn() {
+                fib = fn(n) {
+                    if (n <= 2) {
+                        return 1
+                    } else {
+                        return fib(n-1) + fib(n-2)
+                    }
+                }
+                fib(5)
+            }
+
+            wrap()
+            "#,
+            Object::Integer(5),
+        ),
+        (
+            r#"
+            outer = fn(do) {
+                inner = fn() {
+                    outer(false)
+                }
+
+                if (do) {
+                    inner()
+                } else {
+                    42
+                }
+            }
+            outer(true)
+            "#,
+            Object::Integer(42),
+        ),
+    ];
+
+    for (input, expected) in tests {
+        run_test(input, Ok(expected));
+    }
+}