Improved type checker error messages for clarity

Author: Rafael-Sapienza

src/interpreter/expression_eval.rs

@@ -450,8 +450,8 @@ pub fn eval_function_call(
                             //This will never happen, but I need to cover all cases, otherwise it won't compile
                             _ => {
                                 return Err(format!(
-                                    "[Runtime Error] Function {} expected another function as argument, but received a non functional argument",
-                                    func_name
+                                    "[Runtime Error] Function {:?} expected another function as argument, but received a non functional argument",
+                                    func_signature
                                 ));
                             }
                         }

src/type_checker/expression_type_checker.rs

@@ -90,8 +90,8 @@ pub fn check_func_call(
     let func = env.lookup_function(&func_signature);
     if func.is_none() {
         return Err(format!(
-            "Function {} was called but never declared",
-            func_name
+            "Function {:?} was called but never declared",
+            func_signature
         ));
     }
     let func = func.unwrap();
@@ -105,10 +105,10 @@ pub fn check_func_call(
     for (formal_type, actual_type) in formal_arg_types.iter().zip(actual_arg_types.iter()) {
         if formal_type != actual_type {
             return Err(format!(
-                "Mismatched types in function {} call \n
+                "Mismatched types in function {:?} call \n
             Expected:{:?}\n
             Received: {:?}",
-                func_name, formal_arg_types, actual_arg_types
+                func_signature, formal_arg_types, actual_arg_types
             ));
         }
     }

src/type_checker/statement_type_checker.rs

@@ -210,20 +210,21 @@ fn check_func_def_stmt(
     env: &Environment<Type>,
 ) -> Result<Environment<Type>, ErrorMessage> {
     let mut new_env = Environment::new();
+    let func_signature = FuncSignature::from_func(&function);
     //new_env.push(); -> Push and pop will happen in check_block_statement
-    new_env.set_current_func(&FuncSignature::from_func(&function));
+    new_env.set_current_func(&func_signature);
     // 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 in current scope
     let current_scope = env.get_current_scope();
     if current_scope
         .functions
-        .contains_key(&FuncSignature::from_func(&function))
+        .contains_key(&func_signature)
     {
         return Err(format!(
-            "Function {} is defined multiple times",
-            function.name
+            "Function {:?} is defined multiple times",
+            func_signature
         ));
     }
 
@@ -232,8 +233,8 @@ fn check_func_def_stmt(
     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
+                "Duplicate parameter name '{}' found in function '{:?}'",
+                arg.argument_name, func_signature
             ));
         }
     }