Fix: propagate outer functions to new_env for recursion support

Previously, new_env was not receiving functions from the outer environment,
which caused external functions to be inaccessible inside function bodies.
This also broke recursion, since the function itself wasn't visible in its own scope.

This commit ensures that external functions are copied into new_env,
allowing function bodies to reference both external and self-defined functions.

Author: Rafael-Sapienza

src/environment/environment.rs

@@ -52,18 +52,33 @@ impl<A: Clone> Scope<A> {
 
 #[derive(Clone)]
 pub struct Environment<A> {
+    pub current_func: String,
     pub globals: Scope<A>,
     pub stack: LinkedList<Scope<A>>,
 }
 
 impl<A: Clone> Environment<A> {
     pub fn new() -> Environment<A> {
         Environment {
+            current_func: String::new(),
             globals: Scope::new(),
             stack: LinkedList::new(),
         }
     }
 
+    pub fn get_current_func(&self) -> String {
+        return self.current_func.clone();
+    }
+
+    pub fn set_current_func(&mut self, func_name: &str) {
+        self.current_func = func_name.to_string();
+    }
+
+    pub fn set_global_functions(&mut self, global_functions: HashMap<Name, Function>) {
+        self.globals.functions = global_functions;
+    }
+    
+
     pub fn map_variable(&mut self, var: Name, mutable: bool, value: A) -> () {
         match self.stack.front_mut() {
             None => self.globals.map_variable(var, mutable, value),
@@ -142,9 +157,22 @@ impl<A: Clone> Environment<A> {
                 vars.push((name.clone(), value.clone()));
             }
         }
-
         vars
     }
+
+    // The type checker ensures that each function is defined only once
+    pub fn get_all_functions(&self) -> HashMap<Name,Function> {
+        let mut all_functions = HashMap::new();
+        for (name, func) in &self.globals.functions {
+            all_functions.insert(name.clone(), func.clone());
+        }
+        for scope in self.stack.iter() {
+            for (name, func) in &scope.functions {
+                all_functions.insert(name.clone(), func.clone());
+            }
+        }
+        all_functions
+    }
 }
 
 #[cfg(test)]

src/interpreter/expression_eval.rs

@@ -1,5 +1,5 @@
 use super::statement_execute::Computation;
-use crate::environment::environment::Environment;
+use crate::environment::environment::{Environment, Scope};
 use crate::ir::ast::{Expression, Name};
 
 #[derive(Debug, PartialEq, Clone)]
@@ -398,7 +398,13 @@ pub fn eval_function_call(
                 ));
             }
 
-            new_env.push();
+            // new_env.push(); <- Removed the push; parameters are now mapped directly to the global scope
+            //In this new environment, external functions and actual parameters are regarded as globally accessible
+            //This is justified, since their visibility extends across the entire function body
+            new_env.set_current_func(&name);
+            // Functions from the outer environment must be propagated to new_env to ensure access to external functions within the function body.
+            // This also allows the function to reference itself, which enables recursion
+            new_env.set_global_functions(env.get_all_functions()); 
 
             for (formal, actual) in function_definition.params.iter().zip(args.iter()) {
                 let value = match eval(actual.clone(), env)? {
@@ -410,9 +416,11 @@ pub fn eval_function_call(
                 new_env.map_variable(formal.argument_name.clone(), false, value);
             }
 
+
+
             // Execute the body of the function.
             match super::statement_execute::execute(
-                *function_definition.body.as_ref().unwrap().clone(),
+                *function_definition.body.as_ref().unwrap().clone(), //Push occurs here, because function body is a Statement::Block
                 &new_env,
             ) {
                 Ok(Computation::Continue(_)) => Err("Function did not return a value".to_string()),