feat(type-checker): implement function call and block checking, update return and function definition

- Created `check_block_stmt` to handle scoped type checking of block statements
- Created `check_func_call` to validate function call expressions
- Updated `check_return_stmt` to ensure return type matches declared function type
- Improved `check_func_def_stmt` to handle duplicate declarations and parameter validation

These changes improve the accuracy and robustness of the type checker.

Author: Rafael-Sapienza

src/environment/environment.rs

@@ -77,7 +77,6 @@ impl<A: Clone> Environment<A> {
     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() {
@@ -161,7 +160,7 @@ impl<A: Clone> Environment<A> {
     }
 
     // The type checker ensures that each function is defined only once
-    pub fn get_all_functions(&self) -> HashMap<Name,Function> {
+    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());

src/interpreter/expression_eval.rs

@@ -404,7 +404,7 @@ pub fn eval_function_call(
             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()); 
+            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)? {
@@ -416,8 +416,6 @@ 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(), //Push occurs here, because function body is a Statement::Block

src/interpreter/statement_execute.rs

@@ -211,8 +211,7 @@ pub fn execute_block(
     for stmt in stmts {
         match execute(stmt, &current_env)? {
             Computation::Continue(new_env) => current_env = new_env,
-            Computation::Return(expr, mut new_env) => 
-            {
+            Computation::Return(expr, mut new_env) => {
                 new_env.pop(); //expr has already been evaluated, so it is safe to pop here
                 return Ok(Computation::Return(expr, new_env));
             }
@@ -234,8 +233,7 @@ pub fn execute_if_block(
     for stmt in stmts {
         match execute(stmt, &current_env)? {
             Computation::Continue(new_env) => current_env = new_env,
-            Computation::Return(expr, new_env) => 
-            {
+            Computation::Return(expr, new_env) => {
                 return Ok(Computation::Return(expr, new_env));
             }
             Computation::PropagateError(expr, new_env) => {

src/type_checker/expression_type_checker.rs

@@ -35,13 +35,14 @@ pub fn check_expr(exp: Expression, env: &Environment<Type>) -> Result<Type, Erro
         Expression::Propagate(e) => check_propagate_type(*e, env),
         Expression::ListValue(elements) => check_list_value(&elements, env),
         Expression::Constructor(name, args) => check_adt_constructor(name, args, env),
-        Expression::FuncCall(func_name, exp_vec) => check_func_call(func_name.clone(), exp_vec.clone(), env),
-        
+        Expression::FuncCall(func_name, exp_vec) => {
+            check_func_call(func_name.clone(), exp_vec.clone(), env)
+        }
+
         _ => Err("not implemented yet.".to_string()),
     }
 }
 
-
 fn check_func_call(
     func_name: Name,
     exp_vector: Vec<Expression>,

src/type_checker/statement_type_checker.rs

@@ -1,3 +1,6 @@
+use std::collections::HashSet;
+use std::fmt::format;
+
 use crate::environment::environment::Environment;
 use crate::ir::ast::{Expression, Function, Name, Statement, Type, ValueConstructor};
 use crate::type_checker::expression_type_checker::check_expr;
@@ -20,6 +23,7 @@ pub fn check_stmt(
         Statement::For(var, expr, stmt) => check_for_stmt(var, expr, stmt, env),
         Statement::FuncDef(function) => check_func_def_stmt(function, env),
         Statement::TypeDeclaration(name, cons) => check_adt_declarations_stmt(name, cons, env),
+        Statement::Block(statements_vector) => check_block_statement(statements_vector, env),
         Statement::Return(exp) => check_return_stmt(exp, env),
         _ => Err("Not implemented yet".to_string()),
     }
@@ -34,6 +38,19 @@ fn check_squence_stmt(
     check_stmt(*stmt2, &new_env)
 }
 
+fn check_block_statement(
+    statements_vector: Vec<Statement>,
+    env: &Environment<Type>,
+) -> Result<Environment<Type>, ErrorMessage> {
+    let mut new_env = env.clone();
+    new_env.push();
+    for statement in &statements_vector {
+        new_env = check_stmt(statement.clone(), &new_env)?;
+    }
+    new_env.pop();
+    return Ok(new_env);
+}
+
 fn check_assignment_stmt(
     name: Name,
     exp: Box<Expression>,
@@ -181,8 +198,30 @@ fn check_func_def_stmt(
     function: Function,
     env: &Environment<Type>,
 ) -> Result<Environment<Type>, ErrorMessage> {
-    let mut new_env = env.clone();
-    new_env.push();
+    let mut new_env = Environment::new();
+    //new_env.push(); -> Push and pop will happen in check_block_statement
+    new_env.set_current_func(&function.name);
+    // Previous environment functions and the formal parameters are regarded as global
+    new_env.set_global_functions(env.get_all_functions());
+
+    // Ensure that each function is defined only once
+    if new_env.globals.functions.contains_key(&function.name) {
+        return Err(format!(
+            "Function {} is defined multiple times",
+            function.name
+        ));
+    }
+
+    // Ensure that no parameter names are repeated in the function's argument list
+    let mut seen_names = HashSet::new();
+    for arg in &function.params {
+        if !seen_names.insert(arg.argument_name.clone()) {
+            return Err(format!(
+                "Duplicate parameter name '{}' found in function '{}'",
+                arg.argument_name, function.name
+            ));
+        }
+    }
 
     for formal_arg in function.params.iter() {
         new_env.map_variable(
@@ -192,13 +231,15 @@ fn check_func_def_stmt(
         );
     }
 
+    new_env.map_function(function.clone());
     if let Some(body) = function.body.clone() {
-        new_env = check_stmt(*body, &new_env)?;
+        check_stmt(*body, &new_env)?; //new_env is only used to check function body 
     }
-    new_env.pop();
-    new_env.map_function(function);
+    //new_env.pop();
 
-    Ok(new_env)
+    let mut final_env = env.clone();
+    final_env.map_function(function.clone());
+    Ok(final_env) // if function body is ok, return original env with new function
 }
 
 fn check_adt_declarations_stmt(
@@ -215,19 +256,30 @@ fn check_return_stmt(
     exp: Box<Expression>,
     env: &Environment<Type>,
 ) -> Result<Environment<Type>, ErrorMessage> {
-    let mut new_env = env.clone();
+    let new_env = env.clone();
 
     assert!(new_env.scoped_function());
 
     let ret_type = check_expr(*exp, &new_env)?;
 
-    match new_env.lookup(&"return".to_string()) {
-        Some(_) => Ok(new_env),
-        None => {
-            new_env.map_variable("return".to_string(), false, ret_type);
-            Ok(new_env)
-        }
+    let current_func = env.lookup_function(&env.current_func);
+
+    if current_func.is_none() {
+        return Err(format!("Type checker: No function to return from"));
+    }
+
+    let current_func = current_func.unwrap();
+
+    if ret_type != current_func.kind {
+        return Err(format!(
+            "Error in function {}:
+        Actual return type cannot be different from formal return type \n 
+        Actual return type: {:?} \n
+        Formal return type: {:?}",
+            env.current_func, ret_type, current_func.kind
+        ));
     }
+    return Ok(new_env);
 }
 
 fn merge_environments(