Refatoração do Type Checker para gerar AST Anotada

src/ir/mod.rs

@@ -0,0 +1,2 @@
+pub mod ast;
+pub mod typed_ast;

src/ir/typed_ast.rs

@@ -0,0 +1,250 @@
+use crate::ir::ast::{Name, Type, ValueConstructor,FormalArgument};
+
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum TypedExpression {
+    CTrue { type_info: Type },
+    CFalse { type_info: Type },
+    CInt { value: i32, type_info: Type },
+    CReal { value: f64, type_info: Type },
+    CString { value: String, type_info: Type },
+    CVoid { type_info: Type },
+
+    Var { name: Name, type_info: Type },
+
+    // Expressões aritméticas
+    Add {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type,
+    },
+    Sub {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type,
+    },
+    Mul{
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type,
+    },
+    Div{
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type,
+    },
+
+    And {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type, 
+    },
+    Or {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type, 
+    },
+    Not {
+        expr: Box<TypedExpression>,
+        type_info: Type, 
+    },
+
+    // Relational expressions over numbers
+    EQ {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type,
+    },
+    NEQ {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type, 
+    },
+    GT {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type, 
+    },
+    LT {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type, 
+    },
+    GTE {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type, 
+    },
+    LTE {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        type_info: Type, 
+    },
+
+    COk { expr: Box<TypedExpression>, type_info: Type },    
+    CErr { expr: Box<TypedExpression>, type_info: Type },   
+    CJust { expr: Box<TypedExpression>, type_info: Type },   
+    CNothing { type_info: Type },                      
+
+    Unwrap { expr: Box<TypedExpression>, type_info: Type }, 
+    IsError { expr: Box<TypedExpression>, type_info: Type }, 
+    IsNothing { expr: Box<TypedExpression>, type_info: Type }, 
+    Propagate { expr: Box<TypedExpression>, type_info: Type }, 
+
+    // List value
+    ListValue {
+        elements: Vec<TypedExpression>,
+        type_info: Type, 
+    },
+
+    // Constructor
+    Constructor {
+        name: Name,
+        args: Vec<Box<TypedExpression>>,
+        type_info: Type, 
+    },
+
+    FuncCall {
+        name: Name,
+        args: Vec<Box<TypedExpression>>,
+        type_info: Type,
+    },
+
+}
+
+impl TypedExpression {
+    pub fn type_info(&self) -> &Type {
+        match self {
+            TypedExpression::CTrue { type_info } => type_info,
+            TypedExpression::CFalse { type_info } => type_info,
+            TypedExpression::CInt { type_info, .. } => type_info,
+            TypedExpression::CReal { type_info, .. } => type_info,
+            TypedExpression::CString { type_info, .. } => type_info,
+            TypedExpression::CVoid { type_info } => type_info,
+            TypedExpression::Var { type_info, .. } => type_info,
+            TypedExpression::FuncCall { type_info, .. } => type_info,
+
+            // Arithmetic expressions
+            TypedExpression::Add { type_info, .. } => type_info,
+            TypedExpression::Sub { type_info, .. } => type_info,
+            TypedExpression::Mul { type_info, .. } => type_info,
+            TypedExpression::Div { type_info, .. } => type_info,
+
+            // Boolean expressions
+            TypedExpression::And { type_info, .. } => type_info,
+            TypedExpression::Or { type_info, .. } => type_info,
+            TypedExpression::Not { type_info, .. } => type_info,
+
+            // Relational expressions
+            TypedExpression::EQ { type_info, .. } => type_info,
+            TypedExpression::NEQ { type_info, .. } => type_info,
+            TypedExpression::GT { type_info, .. } => type_info,
+            TypedExpression::LT { type_info, .. } => type_info,
+            TypedExpression::GTE { type_info, .. } => type_info,
+            TypedExpression::LTE { type_info, .. } => type_info,
+
+            // Error-related expressions
+            TypedExpression::COk { type_info, .. } => type_info,
+            TypedExpression::CErr { type_info, .. } => type_info,
+            TypedExpression::CJust { type_info, .. } => type_info,
+            TypedExpression::CNothing { type_info } => type_info,
+            TypedExpression::Unwrap { type_info, .. } => type_info,
+            TypedExpression::IsError { type_info, .. } => type_info,
+            TypedExpression::IsNothing { type_info, .. } => type_info,
+            TypedExpression::Propagate { type_info, .. } => type_info,
+
+            // List and Constructor
+            TypedExpression::ListValue { type_info, .. } => type_info,
+            TypedExpression::Constructor { type_info, .. } => type_info,
+        }
+    }
+}
+
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct TypedFunction {
+    pub name: Name,
+    pub kind: Type,
+    pub params: Vec<FormalArgument>, 
+    pub body: Option<Box<TypedStatement>>,
+}
+
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum TypedStatement {
+
+    // Declaração de variável agora contém uma TypedExpression
+    VarDeclaration {
+        name: Name,
+        value: Box<TypedExpression>,
+    },
+    ValDeclaration {
+        name: Name,
+        value: Box<TypedExpression>,
+    },
+    Assignment {
+        name: Name,
+        value: Box<TypedExpression>,
+    },
+
+    IfThenElse {
+        cond: Box<TypedExpression>,
+        stmt_then: Box<TypedStatement>,
+        stmt_else_opt: Option<Box<TypedStatement>>,
+    },
+    While {
+        cond: Box<TypedExpression>,
+        body: Box<TypedStatement>,
+    },
+    For {
+        name: Name,
+        iterable: Box<TypedExpression>,
+        body: Box<TypedStatement>,
+    },
+
+    Block(Vec<TypedStatement>),
+
+    Sequence {
+    first: Box<TypedStatement>,
+    second: Box<TypedStatement>,
+    },
+
+    Assert {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+    },
+    AssertTrue {
+        expr: Box<TypedExpression>,
+        message: String,
+    },
+    AssertFalse {
+        expr: Box<TypedExpression>,
+        message: String,
+    },
+    AssertEQ {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        message: String,
+    },
+    AssertNEQ {
+        left: Box<TypedExpression>,
+        right: Box<TypedExpression>,
+        message: String,
+    },
+
+    TestDef(TypedFunction),
+    ModTestDef {
+        name: Name,
+        body: Box<TypedStatement>,
+    },
+
+    AssertFails(String),
+
+    FuncDef(TypedFunction),
+
+    Return(Box<TypedExpression>),
+
+    TypeDeclaration(Name, Vec<ValueConstructor>),
+
+
+}

src/main.rs

@@ -10,14 +10,95 @@ use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;*/
 
+use crate::type_checker::check_stmt;
+use crate::environment::environment::Environment;
+use crate::ir::ast::Type;
+
 pub mod environment;
 pub mod interpreter;
 pub mod ir;
 pub mod parser;
 pub mod type_checker;
 
+use crate::ir::ast::{Expression, Statement};
+
 fn main() {
-    println!("Hello, world!");
+    let source_code = "
+        var x = 10;
+        var y = true;
+        if y {
+            x = x + 5;
+        }
+    ";
+
+    println!("--- Código Fonte ---");
+    println!("{}", source_code);
+
+    /*
+    let statements = match parse(source_code) {
+        Ok((_, stmts)) => stmts,
+        Err(e) => {
+            println!("Erro de Parse: {:?}", e);
+            return;
+        }
+    };
+    */
+
+    // Simulação do parser
+    println!("\n--- [SIMULAÇÃO] Gerando AST manualmente ---");
+    let statements = vec![
+        // Corresponde a: var x = 10;
+        Statement::VarDeclaration(
+            "x".to_string(),
+            Box::new(Expression::CInt(10))
+        ),
+        // Corresponde a: var y = true;
+        Statement::VarDeclaration(
+            "y".to_string(),
+            Box::new(Expression::CTrue)
+        ),
+        // Corresponde a: if y { x = x + 5; }
+        Statement::IfThenElse(
+            Box::new(Expression::Var("y".to_string())),      
+            Box::new(Statement::Assignment(                     
+                "x".to_string(),                              
+                Box::new(Expression::Add(                      
+                    Box::new(Expression::Var("x".to_string())), 
+                    Box::new(Expression::CInt(5))               
+                ))
+            )),                                                
+            None 
+        )
+    ];
+
+
+    let mut env: Environment<Type> = Environment::new();
+    println!("\n--- Verificando Tipos... ---");
+
+    for stmt in &statements {
+        match check_stmt(stmt.clone(), &env) {
+            Ok((typed_stmt, new_env)) => {
+                println!("\n Statement OK. AST Tipada gerada:");
+                println!("{:#?}", typed_stmt);
+
+                env = new_env; 
+
+                println!("--- Ambiente após esta statement ---");
+                for (name, (is_mutable, var_type)) in env.get_all_variables() {
+                    let mutability_str = if is_mutable { "var" } else { "val" };
+                    println!("  - {} {}: {:?}", mutability_str, name, var_type);
+                }
+                println!("------------------------------------");
+            }
+            Err(e) => {
+                println!("\n Erro de Tipo Encontrado:");
+                println!("{}", e);
+                return;
+            }
+        }
+    }
+
+    println!("\n\nVerificação de tipos concluída com sucesso para todo o programa!");
 }
 /*
 fn run_test(name: &str, program: &str) -> String {