[fix] Function arguments are only a vector of FormalArgument, instead of an Option.

Author: rbonifacio

src/environment/environment.rs

@@ -167,14 +167,14 @@ mod tests {
         let global_func = Function {
             name: "global".to_string(),
             kind: Type::TVoid,
-            params: None,
+            params: Vec::new(),
             body: None,
         };
 
         let local_func = Function {
             name: "local".to_string(),
             kind: Type::TVoid,
-            params: None,
+            params: Vec::new(),
             body: None,
         };
 

src/interpreter/interpreter.rs

@@ -372,11 +372,23 @@ fn call(
             }
 
             // Bind arguments
-            if let Some(params) = &func.params {
-                for (param, arg) in params.iter().zip(args) {
-                    let arg_value = eval(arg, env)?;
-                    new_env.insert_variable(param.0.clone(), arg_value);
+            for (i, formal_arg) in func.params.iter().enumerate() {
+                if i >= args.len() {
+                    return Err((format!(
+                        "[Runtime Error on '{}()'] missing argument '{}'.",
+                        env.scope_name(),
+                        formal_arg.argumentName
+                    ), None));
                 }
+                let arg_value = eval(args[i].clone(), env)?;
+                new_env.insert_variable(formal_arg.argumentName.clone(), arg_value);
+            }
+
+            if args.len() > func.params.len() {
+                return Err((format!(
+                    "[Runtime Error on '{}()'] too many arguments.",
+                    env.scope_name()
+                ), None));
             }
 
             // Execute function

src/ir/ast.rs

@@ -115,7 +115,7 @@ impl<A> Environment<A> {
 pub struct Function {
     pub name: Name,
     pub kind: Type,
-    pub params: Option<Vec<(Name, Type)>>,
+    pub params: Vec<FormalArgument>,
     pub body: Option<Box<Statement>>,
 }
 
@@ -124,7 +124,7 @@ impl Function {
         return Function {
             name: "__main__".to_string(),
             kind: Type::TVoid,
-            params: None,
+            params: Vec::new(),
             body: None,
         };
     }

src/parser/parser_stmt.rs

@@ -132,15 +132,10 @@ fn parse_function_definition_statement(input: &str) -> IResult<&str, Statement>
             parse_block
         )),
         |(_, name, args, _, t, block)| {
-            let params = args
-                .into_iter()
-                .map(|f| (f.argumentName, f.argumentType))
-                .collect::<Vec<_>>();
-
             Statement::FuncDef(Function {
                 name: name.to_string(),
                 kind: t,
-                params: Some(params),
+                params: args,
                 body: Some(Box::new(block))
             })
         }
@@ -260,7 +255,7 @@ mod tests {
         let expected = Statement::FuncDef(Function {
             name: "f".to_string(),
             kind: Type::TInteger,
-            params: Some(vec![("x".to_string(), Type::TInteger)]),
+            params: vec![FormalArgument::new("x".to_string(), Type::TInteger)],
             body: Some(Box::new(Statement::Block(vec![
                 Statement::Assignment("x".to_string(), Box::new(Expression::CInt(1)))
             ]))),

src/tc/type_checker.rs

@@ -1,5 +1,5 @@
 use crate::environment::environment::Environment;
-use crate::ir::ast::{Expression, Name, Statement, Type};
+use crate::ir::ast::{Expression, Name, Statement, Type, Function, FormalArgument};
 
 type ErrorMessage = String;
 
@@ -114,11 +114,12 @@ pub fn check_stmt(
         Statement::FuncDef(function) => {
             let mut new_env = env.clone();
             new_env.push();
-            if let Some(params) = function.params.clone() {
-                for (param_name, param_type) in params {
-                    new_env.map_variable(param_name, param_type)
-                }
+            
+            // Since params is now a Vec<FormalArgument>, we can iterate directly
+            for formal_arg in function.params.iter() {
+                new_env.map_variable(formal_arg.argumentName.clone(), formal_arg.argumentType.clone());
             }
+            
             if let Some(body) = function.body.clone() {
                 new_env = check_stmt(*body, &new_env)?;
             }
@@ -207,55 +208,6 @@ pub fn check_stmt(
 //     }
 // }
 
-// fn check_func_call(
-//     name: String,
-//     args: Vec<Expression>,
-//     env: &Environment<Type>,
-// ) -> Result<Type, ErrorMessage> {
-//     match check_var_name(name.clone(), env, false) {
-//         Ok(Type::TFunction(kind, type_vec)) => {
-//             if args.len() != type_vec.len() {
-//                 return Err(format!(
-//                     "[Type Error on '{}()'] '{}()' expected {} arguments, found {}.",
-//                     env.scope_name(),
-//                     name,
-//                     type_vec.len(),
-//                     args.len()
-//                 ));
-//             }
-
-//             for (arg, param_type) in args.iter().zip(type_vec) {
-//                 let arg_type = check_exp(arg.clone(), env)?;
-//                 if arg_type != param_type {
-//                     return Err(format!("[Type Error on '{}()'] '{}()' has mismatched arguments: expected '{:?}', found '{:?}'.", env.scope_name(), name, param_type, arg_type));
-//                 }
-//             }
-
-//             Ok(kind.unwrap())
-//         }
-//         _ => Err(format!(
-//             "[Name Error on '{}()'] '{}()' is not defined.",
-//             env.scope_name(),
-//             name
-//         )),
-//     }
-// }
-
-// fn check_duplicate_params(params: &Vec<(Name, Type)>) -> Result<(), ErrorMessage> {
-//     let mut seen_params = std::collections::HashSet::new();
-
-//     for (name, _) in params {
-//         if !seen_params.insert(name.clone()) {
-//             return Err(format!(
-//                 "[Parameter Error] Duplicate parameter name '{}'",
-//                 name
-//             ));
-//         }
-//     }
-
-//     Ok(())
-// }
-
 fn check_var_name(name: Name, env: &Environment<Type>, scoped: bool) -> Result<Type, ErrorMessage> {
     let var_type = env.lookup(&name);
     match var_type {
@@ -773,10 +725,10 @@ mod tests {
         let func = FuncDef(Function {
             name: "add".to_string(),
             kind: Type::TInteger,
-            params: Some(vec![
-                ("a".to_string(), TInteger),
-                ("b".to_string(), TInteger),
-            ]),
+            params: vec![
+                FormalArgument::new("a".to_string(), Type::TInteger),
+                FormalArgument::new("b".to_string(), Type::TInteger),
+            ],
             body: Some(Box::new(Return(Box::new(Add(
                 Box::new(Var("a".to_string())),
                 Box::new(Var("b".to_string())),
@@ -916,14 +868,14 @@ mod tests {
         let global_func = Function {
             name: "global".to_string(),
             kind: Type::TVoid,
-            params: None,
+            params: Vec::new(),
             body: None,
         };
 
         let local_func = Function {
             name: "local".to_string(),
             kind: Type::TVoid,
-            params: None,
+            params: Vec::new(),
             body: None,
         };
 

tests/parser_tests.rs

@@ -213,11 +213,11 @@ mod statement_tests {
         let input = "def add(x: Int, y: Int) -> Int: return x + y; end";
         let expected = Statement::FuncDef(Function {
             name: "add".to_string(),
-            kind: Some(Type::TInteger),
-            params: Some(vec![
-                ("x".to_string(), Type::TInteger),
-                ("y".to_string(), Type::TInteger),
-            ]),
+            kind: Type::TInteger,
+            params: vec![
+                FormalArgument::new("x".to_string(), Type::TInteger),
+                FormalArgument::new("y".to_string(), Type::TInteger),
+            ],
             body: Some(Box::new(Statement::Block(vec![Statement::Return(Box::new(
                 Expression::Add(
                     Box::new(Expression::Var("x".to_string())),