Implement closures

Cargo.toml

@@ -10,13 +10,13 @@ description = "An interpreter for the Lox language (http://craftinginterpreters.
 clap = { version = "4.5.2", features = ["derive", "env", "string"] }
 miette = { version = "7.2.0", features = ["fancy", "syntect-highlighter"] }
 phf = { version = "0.11.2", features = ["macros"] }
-thiserror = "1.0.57"
+thiserror = "1.0.58"
 strum = { version = "0.26", features = ["derive"] }
 rustyline = {version= "14.0.0", features = ["with-file-history", "derive"]}
 directories = "5.0.1"
+fragile = "2.0.0"
 
 [dev-dependencies]
-anyhow = "1.0.80"
 assert_matches = "1.5"
 float_eq = "1.0.1"
 datadriven = "0.8.0"

src/interpreter/callable.rs

@@ -1,4 +1,5 @@
 use core::fmt::Display;
+use std::{cell::RefCell, rc::Rc};
 
 use crate::ast::{expr::Name, stmt::Stmt};
 
@@ -17,6 +18,7 @@ pub enum Callable {
         name: Name,
         parameters: Vec<Name>,
         body: Vec<Stmt>,
+        closure: Rc<RefCell<Environment>>,
     },
 }
 
@@ -25,18 +27,20 @@ impl Callable {
         match self {
             Native { function, .. } => function(interpreter, arguments),
             Function {
-                parameters, body, ..
+                parameters,
+                body,
+                closure,
+                ..
             } => {
-                let global = interpreter.global.clone();
-                let mut env = Environment::from_parent(global);
+                let mut env = Environment::from_parent(closure.clone());
                 parameters
                     .iter()
                     .zip(arguments.iter())
                     .for_each(|(p, a)| env.define(p, a.clone()));
                 let result = interpreter.execute_block(body, env);
                 match result {
                     Ok(_) => Ok(Value::Nil),
-                    Err(RuntimeError::Return { value, .. }) => Ok(value),
+                    Err(RuntimeError::Return { value, .. }) => Ok(value.get().clone()),
                     Err(err) => Err(err),
                 }
             }

src/interpreter/environment.rs

@@ -4,7 +4,7 @@ use crate::ast::expr::Name;
 
 use super::{native_functions::native_functions, value::Value};
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct Environment {
     pub parent: Option<Rc<RefCell<Environment>>>,
     values: HashMap<Name, Value>,

src/interpreter/runtime_error.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use fragile::Fragile;
 use miette::{Diagnostic, NamedSource, SourceSpan};
 
 use crate::{ast::expr::Name, interpreter::types::Type};
@@ -81,7 +82,7 @@ pub enum RuntimeError {
     },
     #[error("Return can not be used outside of functions")]
     Return {
-        value: Value,
+        value: Fragile<Value>, //TODO: Reevaluate if we need this after resolving and binding
         #[source_code]
         src: Arc<NamedSource<String>>,
         #[label("here")]

src/interpreter/statement.rs

@@ -1,5 +1,6 @@
 use std::{cell::RefCell, rc::Rc, sync::Arc};
 
+use fragile::Fragile;
 use miette::{NamedSource, SourceSpan};
 
 use crate::ast::{
@@ -55,6 +56,7 @@ impl Interpreter {
             name: name.clone(),
             parameters: arguments.to_vec(),
             body: body.to_vec(),
+            closure: self.environment.clone(),
         };
         self.environment
             .borrow_mut()
@@ -99,6 +101,7 @@ impl Interpreter {
     ) -> Result<()> {
         let value = expr.as_ref().map(|e| self.interpret_expr(e)).transpose()?;
         let value = value.unwrap_or(Value::Nil);
+        let value = Fragile::new(value);
         Err(RuntimeError::Return {
             value,
             src,

tests/closure.lox

@@ -0,0 +1,15 @@
+interpret
+fun make_counter() {
+    var i = 0;
+    fun count() {
+        i=i+1;
+        print i;
+    }
+    return count;
+}
+var counter = make_counter();
+counter();
+counter();
+----
+1
+2