[refactoring] Enhance environment to support mutable and non-mutable variables

- Update Environment to differentiate mutable and non-mutable variables:
  - Add mutable flag to variable storage in Scope
  - Update lookup to return (bool, Type) tuple indicating mutability
  - Modify map_variable to require mutability parameter

- Add type checking for new statements:
  - val declaration (non-mutable)
  - var declaration (mutable)
  - if-then-else with proper type checking
  - for loops with type checking
  - while loops with type checking

- Update test suite:
  - Add tests for mutable/non-mutable variable behavior
  - Add tests for new statement type checking
  - Fix existing tests to declare variables before assignment

- Clean up source code:
  - Remove old type checker files (tc/*)
  - Reorganize type checking logic
  - Improve error messages

Author: rbonifacio

src/environment/environment.rs

@@ -1,26 +1,27 @@
 use crate::ir::ast::Function;
 use crate::ir::ast::Name;
-use crate::ir::ast::Type;
-
+use crate::ir::ast::ValueConstructor;
 use std::collections::HashMap;
 use std::collections::LinkedList;
 
 #[derive(Clone)]
 pub struct Scope<A> {
-    pub variables: HashMap<Name, A>,
+    pub variables: HashMap<Name, (bool, A)>,
     pub functions: HashMap<Name, Function>,
+    pub adts: HashMap<Name, Vec<ValueConstructor>>,
 }
 
 impl<A: Clone> Scope<A> {
     fn new() -> Scope<A> {
         Scope {
             variables: HashMap::new(),
             functions: HashMap::new(),
+            adts: HashMap::new(),
         }
     }
 
-    fn map_variable(&mut self, var: Name, value: A) -> () {
-        self.variables.insert(var, value);
+    fn map_variable(&mut self, var: Name, mutable: bool, value: A) -> () {
+        self.variables.insert(var, (mutable, value));
         return ();
     }
 
@@ -29,13 +30,24 @@ impl<A: Clone> Scope<A> {
         return ();
     }
 
-    fn lookup_var(&self, var: &Name) -> Option<&A> {
-        self.variables.get(var)
+    fn map_adt(&mut self, name: Name, adt: Vec<ValueConstructor>) -> () {
+        self.adts.insert(name.clone(), adt);
+        return ();
+    }
+
+    fn lookup_var(&self, var: &Name) -> Option<(bool, A)> {
+        self.variables
+            .get(var)
+            .map(|(mutable, value)| (*mutable, value.clone()))
     }
 
     fn lookup_function(&self, name: &Name) -> Option<&Function> {
         self.functions.get(name)
     }
+
+    fn lookup_adt(&self, name: &Name) -> Option<&Vec<ValueConstructor>> {
+        self.adts.get(name)
+    }
 }
 
 #[derive(Clone)]
@@ -52,10 +64,10 @@ impl<A: Clone> Environment<A> {
         }
     }
 
-    pub fn map_variable(&mut self, var: Name, value: A) -> () {
+    pub fn map_variable(&mut self, var: Name, mutable: bool, value: A) -> () {
         match self.stack.front_mut() {
-            None => self.globals.map_variable(var, value),
-            Some(top) => top.map_variable(var, value),
+            None => self.globals.map_variable(var, mutable, value),
+            Some(top) => top.map_variable(var, mutable, value),
         }
     }
 
@@ -66,28 +78,40 @@ impl<A: Clone> Environment<A> {
         }
     }
 
-    pub fn lookup(&self, var: &Name) -> Option<&A> {
-        // First check local scopes in order
+    pub fn map_adt(&mut self, name: Name, cons: Vec<ValueConstructor>) -> () {
+        match self.stack.front_mut() {
+            None => self.globals.map_adt(name, cons),
+            Some(top) => top.map_adt(name, cons),
+        }
+    }
+
+    pub fn lookup(&self, var: &Name) -> Option<(bool, A)> {
         for scope in self.stack.iter() {
             if let Some(value) = scope.lookup_var(var) {
                 return Some(value);
             }
         }
-        // Then check global scope
         self.globals.lookup_var(var)
     }
 
     pub fn lookup_function(&self, name: &Name) -> Option<&Function> {
-        // First check local scopes in order
         for scope in self.stack.iter() {
             if let Some(func) = scope.lookup_function(name) {
                 return Some(func);
             }
         }
-        // Then check global scope
         self.globals.lookup_function(name)
     }
 
+    pub fn lookup_adt(&self, name: &Name) -> Option<&Vec<ValueConstructor>> {
+        for scope in self.stack.iter() {
+            if let Some(cons) = scope.lookup_adt(name) {
+                return Some(cons);
+            }
+        }
+        self.globals.lookup_adt(name)
+    }
+
     pub fn scoped_function(&self) -> bool {
         !self.stack.is_empty()
     }
@@ -100,7 +124,7 @@ impl<A: Clone> Environment<A> {
         self.stack.pop_front();
     }
 
-    pub fn get_all_variables(&self) -> Vec<(Name, A)> {
+    pub fn get_all_variables(&self) -> Vec<(Name, (bool, A))> {
         let mut vars = Vec::new();
 
         // First get variables from local scopes (in reverse order to respect shadowing)
@@ -126,37 +150,38 @@ impl<A: Clone> Environment<A> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::ir::ast::Type;
 
     #[test]
     fn test_variable_scoping() {
         let mut env: Environment<i32> = Environment::new();
 
         // Test global scope
-        env.map_variable("x".to_string(), 32);
-        assert_eq!(Some(&32), env.lookup(&"x".to_string()));
+        env.map_variable("x".to_string(), true, 32);
+        assert_eq!(Some((true, 32)), env.lookup(&"x".to_string()));
 
         // Test nested scopes
         env.push(); // scope 1
-        env.map_variable("y".to_string(), 23);
-        env.map_variable("x".to_string(), 55); // shadows global x
+        env.map_variable("y".to_string(), true, 23);
+        env.map_variable("x".to_string(), true, 55); // shadows global x
 
         env.push(); // scope 2
-        env.map_variable("z".to_string(), 44);
+        env.map_variable("z".to_string(), true, 44);
 
         // Variables from all scopes should be accessible
-        assert_eq!(Some(&55), env.lookup(&"x".to_string())); // from scope 1
-        assert_eq!(Some(&23), env.lookup(&"y".to_string())); // from scope 1
-        assert_eq!(Some(&44), env.lookup(&"z".to_string())); // from scope 2
+        assert_eq!(Some((true, 55)), env.lookup(&"x".to_string())); // from scope 1
+        assert_eq!(Some((true, 23)), env.lookup(&"y".to_string())); // from scope 1
+        assert_eq!(Some((true, 44)), env.lookup(&"z".to_string())); // from scope 2
 
         // Pop scope 2
         env.pop();
-        assert_eq!(Some(&55), env.lookup(&"x".to_string())); // still in scope 1
-        assert_eq!(Some(&23), env.lookup(&"y".to_string())); // still in scope 1
+        assert_eq!(Some((true, 55)), env.lookup(&"x".to_string())); // still in scope 1
+        assert_eq!(Some((true, 23)), env.lookup(&"y".to_string())); // still in scope 1
         assert_eq!(None, env.lookup(&"z".to_string())); // z is gone
 
         // Pop scope 1
         env.pop();
-        assert_eq!(Some(&32), env.lookup(&"x".to_string())); // back to global x
+        assert_eq!(Some((true, 32)), env.lookup(&"x".to_string())); // back to global x
         assert_eq!(None, env.lookup(&"y".to_string())); // y is gone
     }
 

src/interpreter/interpreter.rs

@@ -39,9 +39,9 @@ pub fn eval(exp: Expression, env: &Environment<EnvValue>) -> Result<EnvValue, Er
         Expression::IsError(e) => eval_iserror_expression(*e, env),
         Expression::IsNothing(e) => eval_isnothing_expression(*e, env),
         Expression::FuncCall(name, args) => call(name, args, env),
-        Expression::ADTConstructor(adt_name, constructor_name, args) => {
-            adtconstructor_eval(adt_name, constructor_name, args, env)
-        }
+        // Expression::ADTConstructor(constructor_name, args) => {
+        //     adtconstructor_eval(adt_name, constructor_name, args, env)
+        // }
         _ if is_constant(exp.clone()) => Ok(EnvValue::Exp(exp)),
         _ => Err((String::from("Not implemented yet."), None)),
     }
@@ -218,7 +218,7 @@ fn execute(stmt: Statement, env: &Environment<EnvValue>) -> Result<ControlFlow,
             Ok(ControlFlow::Return(exp_value))
         }
 
-        Statement::ADTDeclaration(name, constructors) => {
+        Statement::TypeDeclaration(name, constructors) => {
             // Insert the ADT into the new environment
             new_env.insert_type(name, constructors);
             // Return the new environment along with ControlFlow
@@ -240,95 +240,95 @@ fn execute(stmt: Statement, env: &Environment<EnvValue>) -> Result<ControlFlow,
     }
 }
 
-fn adtconstructor_eval(
-    adt_name: Name,
-    constructor_name: Name,
-    args: Vec<Box<Expression>>,
-    env: &Environment<EnvValue>,
-) -> Result<EnvValue, (String, Option<Expression>)> {
-    if let Some(constructors) = env.get_type(&adt_name) {
-        let value_constructor = constructors.iter().find(|vc| vc.name == constructor_name);
-
-        if let Some(vc) = value_constructor {
-            if vc.types.len() != args.len() {
-                return Err((
-                    format!(
-                        "Error: Constructor {} expects {} arguments, but received {}",
-                        constructor_name,
-                        vc.types.len(),
-                        args.len()
-                    ),
-                    None,
-                ));
-            }
+// fn adtconstructor_eval(
+//     adt_name: Name,
+//     constructor_name: Name,
+//     args: Vec<Box<Expression>>,
+//     env: &Environment<EnvValue>,
+// ) -> Result<EnvValue, (String, Option<Expression>)> {
+//     if let Some(constructors) = env.get_type(&adt_name) {
+//         let value_constructor = constructors.iter().find(|vc| vc.name == constructor_name);
+
+//         if let Some(vc) = value_constructor {
+//             if vc.types.len() != args.len() {
+//                 return Err((
+//                     format!(
+//                         "Error: Constructor {} expects {} arguments, but received {}",
+//                         constructor_name,
+//                         vc.types.len(),
+//                         args.len()
+//                     ),
+//                     None,
+//                 ));
+//             }
 
-            let evaluated_args: Result<Vec<Box<Expression>>, (String, Option<Expression>)> = args
-                .into_iter()
-                .map(|arg| {
-                    eval(*arg, env).and_then(|res| match res {
-                        EnvValue::Exp(e) => Ok(Box::new(e)),
-                        _ => Err((
-                            String::from("Error: Expected expression in ADT constructor arguments"),
-                            None,
-                        )),
-                    })
-                })
-                .collect();
-
-            evaluated_args.map(|evaluated| {
-                EnvValue::Exp(Expression::ADTConstructor(
-                    adt_name,
-                    constructor_name,
-                    evaluated,
-                ))
-            })
-        } else {
-            Err((
-                format!(
-                    "Error: Constructor {} not found in ADT {}",
-                    constructor_name, adt_name
-                ),
-                None,
-            ))
-        }
-    } else {
-        Err((format!("Error: ADT {} not found", adt_name), None))
-    }
-}
+//             let evaluated_args: Result<Vec<Box<Expression>>, (String, Option<Expression>)> = args
+//                 .into_iter()
+//                 .map(|arg| {
+//                     eval(*arg, env).and_then(|res| match res {
+//                         EnvValue::Exp(e) => Ok(Box::new(e)),
+//                         _ => Err((
+//                             String::from("Error: Expected expression in ADT constructor arguments"),
+//                             None,
+//                         )),
+//                     })
+//                 })
+//                 .collect();
+
+//             evaluated_args.map(|evaluated| {
+//                 EnvValue::Exp(Expression::ADTConstructor(
+//                     adt_name,
+//                     constructor_name,
+//                     evaluated,
+//                 ))
+//             })
+//         } else {
+//             Err((
+//                 format!(
+//                     "Error: Constructor {} not found in ADT {}",
+//                     constructor_name, adt_name
+//                 ),
+//                 None,
+//             ))
+//         }
+//     } else {
+//         Err((format!("Error: ADT {} not found", adt_name), None))
+//     }
+// }
 
-fn matches_pattern(
-    value: &EnvValue,
-    pattern: &Expression,
-    env: &Environment<EnvValue>,
-) -> Result<bool, ErrorMessage> {
-    match (value, pattern) {
-        // Caso o padrão seja um construtor de ADT
-        (
-            EnvValue::Exp(Expression::ADTConstructor(adt_name1, constructor_name1, args1)),
-            Expression::ADTConstructor(adt_name2, constructor_name2, args2),
-        ) => {
-            // Verifica se o nome do ADT e o construtor correspondem
-            if adt_name1 == adt_name2 && constructor_name1 == constructor_name2 {
-                // Verifica se os argumentos correspondem
-                for (arg1, arg2) in args1.iter().zip(args2.iter()) {
-                    let arg_value = eval(*arg1.clone(), env)?;
-                    if !matches_pattern(&arg_value, arg2, env)? {
-                        return Ok(false);
-                    }
-                }
-                Ok(true)
-            } else {
-                Ok(false)
-            }
-        }
+// fn matches_pattern(
+//     value: &EnvValue,
+//     pattern: &Expression,
+//     env: &Environment<EnvValue>,
+// ) -> Result<bool, ErrorMessage> {
+//     match (value, pattern) {
+//         // Caso o padrão seja um construtor de ADT
+//         (
+//             EnvValue::Exp(Expression::ADTConstructor(adt_name1, constructor_name1, args1)),
+//             Expression::ADTConstructor(adt_name2, constructor_name2, args2),
+//         ) => {
+//             // Verifica se o nome do ADT e o construtor correspondem
+//             if adt_name1 == adt_name2 && constructor_name1 == constructor_name2 {
+//                 // Verifica se os argumentos correspondem
+//                 for (arg1, arg2) in args1.iter().zip(args2.iter()) {
+//                     let arg_value = eval(*arg1.clone(), env)?;
+//                     if !matches_pattern(&arg_value, arg2, env)? {
+//                         return Ok(false);
+//                     }
+//                 }
+//                 Ok(true)
+//             } else {
+//                 Ok(false)
+//             }
+//         }
 
-        // Caso o padrão seja uma constante (como um número ou booleano)
-        (EnvValue::Exp(exp1), exp2) if is_constant(exp2.clone()) => Ok(exp1 == exp2),
+//         // Caso o padrão seja uma constante (como um número ou booleano)
+//         (EnvValue::Exp(exp1), exp2) if is_constant(exp2.clone()) => Ok(exp1 == exp2),
 
-        // Outros casos podem ser adicionados aqui (como variáveis, etc.)
-        _ => Err(("Pattern not supported".to_string(), None)),
-    }
-}
+//         // Outros casos podem ser adicionados aqui (como variáveis, etc.)
+//         _ => Err(("Pattern not supported".to_string(), None)),
+//     }
+// }
 
 //helper function for executing blocks
 fn execute_block(
@@ -378,13 +378,13 @@ fn call(
                         format!(
                             "[Runtime Error on '{}()'] missing argument '{}'.",
                             env.scope_name(),
-                            formal_arg.argumentName
+                            formal_arg.argument_name
                         ),
                         None,
                     ));
                 }
                 let arg_value = eval(args[i].clone(), env)?;
-                new_env.insert_variable(formal_arg.argumentName.clone(), arg_value);
+                new_env.insert_variable(formal_arg.argument_name.clone(), arg_value);
             }
 
             if args.len() > func.params.len() {