🎁 added return statements

src/errors.rs

@@ -4,12 +4,12 @@ pub enum Error {
     ParseError { token: Token, message: String },
     RuntimeError { token: Token, message: String },
     SystemError { message: String },
-    ReturnValue { value: Object },
+    Return { value: Object },
 }
 
 impl Error {
     pub fn return_value(value: Object) -> Error {
-        Error::ReturnValue { value }
+        Error::Return { value }
     }
 
     pub fn parse_error(token: &Token, message: &str) -> Error {
@@ -51,7 +51,7 @@ impl Error {
             Error::SystemError { message } => {
                 eprintln!("System Error: {message}");
             }
-            Error::ReturnValue { .. } => {}
+            Error::Return { .. } => {}
         };
     }
 }

src/functions.rs

@@ -31,8 +31,15 @@ impl CallableTrait for Function {
             e.define(param.lexeme.clone(), arg.clone());
         }
 
-        interpreter.execute_block(&self.body, e)?;
-        Ok(Object::Nil)   
+        match interpreter.execute_block(&self.body, e) {
+            Ok(_) => Ok(Object::Nil),
+            Err(e) => {
+                match e {
+                    Error::Return { value } => Ok(value),
+                    _ => Err(e),
+                }
+            }
+        }
     }
 
     fn arity(&self) -> usize {

src/interpreter.rs

@@ -15,7 +15,12 @@ pub struct Interpreter {
 
 impl StmtVisitor<()> for Interpreter {
     fn visit_return_stmt(&self, stmt: &ReturnStmt) -> Result<(), Error> {
-        Ok(())
+        if let Some(value) = &stmt.value {
+            let value = self.evaluate(value)?;
+            Err(Error::return_value(value))
+        } else {
+            Err(Error::return_value(Object::Nil))
+        }
     }
     fn visit_function_stmt(&self, stmt: &FunctionStmt) -> Result<(), Error>{
         let function = Function::new(&stmt);